Merge pull request #11 from JoyStream/development

v0.1.3

Author: mnaamani

conan_package/base.py

@@ -3,7 +3,7 @@
 
 class ProtocolWireBase(ConanFile):
     name = "ProtocolWire"
-    version = "0.1.2"
+    version = "0.1.3"
     license = "(c) JoyStream Inc. 2016-2017"
     url = "https://github.com/JoyStream/protocol_wire-cpp.git"
     repo_ssh_url = "git@github.com:JoyStream/protocol_wire-cpp.git"

sources/CMakeLists.txt

@@ -32,6 +32,8 @@ set(
     src/char_array_buffer.cpp
     src/BinaryStreamWriter.cpp
     src/BinaryStreamReader.cpp
+    src/SpeedTestRequest.cpp
+    src/SpeedTestPayload.cpp
 )
 
 # === build library ===

sources/include/protocol_wire/InputWireStream.hpp

@@ -23,6 +23,8 @@ class Ready;
 class RequestFullPiece;
 class FullPiece;
 class Payment;
+class SpeedTestRequest;
+class SpeedTestPayload;
 
 class PieceData;
 class BuyerTerms;
@@ -43,6 +45,8 @@ class InputWireStream : public BinaryStreamReader {
     RequestFullPiece readRequestFullPiece();
     FullPiece readFullPiece();
     Payment readPayment();
+    SpeedTestRequest readSpeedTestRequest();
+    SpeedTestPayload readSpeedTestPayload();
 
 private:
 

sources/include/protocol_wire/OutputWireStream.hpp

@@ -24,6 +24,8 @@ class Ready;
 class RequestFullPiece;
 class FullPiece;
 class Payment;
+class SpeedTestRequest;
+class SpeedTestPayload;
 
 class PieceData;
 class BuyerTerms;
@@ -44,6 +46,8 @@ class OutputWireStream : public BinaryStreamWriter {
     std::streamsize write(const RequestFullPiece&);
     std::streamsize write(const FullPiece&);
     std::streamsize write(const Payment&);
+    std::streamsize write(const SpeedTestRequest&);
+    std::streamsize write(const SpeedTestPayload&);
 
     template<class T>
     static std::streamsize sizeOf(const T& msg) {

sources/include/protocol_wire/SpeedTestPayload.hpp

@@ -0,0 +1,41 @@
+/**
+ * Copyright (C) JoyStream - All Rights Reserved
+ */
+
+#ifndef JOYSTREAM_PROTOCOL_WIRE_SPEED_TEST_PAYLOAD_HPP
+#define JOYSTREAM_PROTOCOL_WIRE_SPEED_TEST_PAYLOAD_HPP
+
+#include <stdint.h>
+#include <iostream>
+
+namespace joystream {
+namespace protocol_wire {
+
+    class SpeedTestPayload {
+
+    public:
+
+        // Default constructor
+        SpeedTestPayload();
+
+        SpeedTestPayload(const uint32_t payloadSize);
+
+        bool operator==(const SpeedTestPayload &) const;
+
+        // Getters and setters
+        uint32_t payloadSize() const;
+        void setPayloadSize(const uint32_t);
+
+        // Overload the << operator for easiness in debugging with GTest
+        friend std::ostream& operator<<(std::ostream &os, const SpeedTestPayload &obj);
+
+    private:
+
+        // Size of the speedtest payload to send
+        uint32_t _payloadSize;
+    };
+
+}
+}
+
+#endif // JOYSTREAM_PROTOCOL_WIRE_BUY_HPP

sources/include/protocol_wire/SpeedTestRequest.hpp

@@ -0,0 +1,41 @@
+/**
+ * Copyright (C) JoyStream - All Rights Reserved
+ */
+
+#ifndef JOYSTREAM_PROTOCOL_WIRE_SPEED_TEST_REQUEST_HPP
+#define JOYSTREAM_PROTOCOL_WIRE_SPEED_TEST_REQUEST_HPP
+
+#include <stdint.h>
+#include <iostream>
+
+namespace joystream {
+namespace protocol_wire {
+
+    class SpeedTestRequest {
+
+    public:
+
+        // Default constructor
+        SpeedTestRequest();
+
+        SpeedTestRequest(const uint32_t payloadSize);
+
+        bool operator==(const SpeedTestRequest &) const;
+
+        // Getters and setters
+        uint32_t payloadSize() const;
+        void setPayloadSize(const uint32_t);
+
+        // Overload the << operator for easiness in debugging with GTest
+        friend std::ostream& operator<<(std::ostream &os, const SpeedTestRequest &obj);
+
+    private:
+
+        // Size of the speedtest payload to send
+        uint32_t _payloadSize;
+    };
+
+}
+}
+
+#endif // JOYSTREAM_PROTOCOL_WIRE_BUY_HPP

sources/include/protocol_wire/protocol_wire.hpp

@@ -23,5 +23,7 @@
 #include <protocol_wire/NetworkInt.hpp>
 #include <protocol_wire/InputWireStream.hpp>
 #include <protocol_wire/OutputWireStream.hpp>
+#include <protocol_wire/SpeedTestRequest.hpp>
+#include <protocol_wire/SpeedTestPayload.hpp>
 
 #endif // JOYSTREAM_PROTOCOLWIRE_HPP

sources/src/InputWireStream.cpp

@@ -9,6 +9,8 @@
 #include <protocol_wire/RequestFullPiece.hpp>
 #include <protocol_wire/FullPiece.hpp>
 #include <protocol_wire/Payment.hpp>
+#include <protocol_wire/SpeedTestRequest.hpp>
+#include <protocol_wire/SpeedTestPayload.hpp>
 
 namespace joystream {
 namespace protocol_wire {
@@ -117,6 +119,34 @@ Payment InputWireStream::readPayment() {
     return payment;
 }
 
+SpeedTestRequest InputWireStream::readSpeedTestRequest() {
+  SpeedTestRequest request;
+
+  auto value = readInt<decltype(request.payloadSize())>();
+
+  request.setPayloadSize(value);
+
+  return request;
+}
+
+SpeedTestPayload InputWireStream::readSpeedTestPayload() {
+  SpeedTestPayload payload;
+
+  auto size = readInt<uint32_t>();
+
+  // check max size limit?
+  if(size > _buffer->in_avail()) {
+      throw std::runtime_error("unable to read speedtest payload, not enough data in stream buffer");
+  }
+
+  // skip over the data, we don't actually care what the payload is, just that it was sent
+  _buffer->pubseekoff(size, std::ios_base::cur, std::ios_base::in);
+
+  payload.setPayloadSize(size);
+
+  return payload;
+}
+
 Coin::PubKeyHash InputWireStream::readPubKeyHash() {
     Coin::PubKeyHash hash;
     readBytes(hash.data(), hash.rawLength());

sources/src/OutputWireStream.cpp

@@ -9,6 +9,8 @@
 #include <protocol_wire/RequestFullPiece.hpp>
 #include <protocol_wire/FullPiece.hpp>
 #include <protocol_wire/Payment.hpp>
+#include <protocol_wire/SpeedTestRequest.hpp>
+#include <protocol_wire/SpeedTestPayload.hpp>
 
 namespace joystream {
 namespace protocol_wire {
@@ -83,6 +85,22 @@ std::streamsize OutputWireStream::write(const Payment &payment) {
     return writeSignature(payment.sig());
 }
 
+std::streamsize OutputWireStream::write(const SpeedTestRequest &speedTestRequest) {
+  return writeInt<uint32_t>(speedTestRequest.payloadSize());
+}
+
+std::streamsize OutputWireStream::write(const SpeedTestPayload &speedTestPayload) {
+  std::streamsize written = 0;
+
+  // Initialize payload to 0xff (we don't want to send a dump of our memory to the other side)
+  std::vector<unsigned char> payload(speedTestPayload.payloadSize(), 0xff);
+
+  written += writeInt<uint32_t>(speedTestPayload.payloadSize());
+  written += writeBytes(payload);
+
+  return written;
+}
+
 std::streamsize OutputWireStream::writePubKeyHash(const Coin::PubKeyHash& hash) {
     return writeBytes(hash.data(), hash.rawLength());
 }

sources/src/SpeedTestPayload.cpp

@@ -0,0 +1,39 @@
+/**
+ * Copyright (C) JoyStream - All Rights Reserved
+ * Unauthorized copying of this file, via any medium is strictly prohibited
+ * Proprietary and confidential
+ * Written by Bedeho Mender <bedeho.mender@gmail.com>, June 26 2015
+ */
+
+#include <protocol_wire/SpeedTestPayload.hpp>
+
+namespace joystream {
+namespace protocol_wire {
+
+    SpeedTestPayload::SpeedTestPayload() :
+      _payloadSize(0) {
+
+    }
+
+    SpeedTestPayload::SpeedTestPayload(const uint32_t payloadSize)
+        : _payloadSize(payloadSize) {
+    }
+
+    bool SpeedTestPayload::operator==(const SpeedTestPayload & o) const {
+        return _payloadSize == o.payloadSize();
+    }
+
+    uint32_t SpeedTestPayload::payloadSize() const {
+        return _payloadSize;
+    }
+
+    void SpeedTestPayload::setPayloadSize(const uint32_t payloadSize) {
+        _payloadSize = payloadSize;
+    }
+
+    std::ostream& operator<<(std::ostream &os, const SpeedTestPayload &obj)
+    {
+        return os << "SpeedTestPayload payloadSize = " << obj.payloadSize();
+    }
+}
+}