receiver recieves image metadata

receiver/src/request.cpp

@@ -31,7 +31,27 @@ Error Request::PrepareDataBuffer() {
     return nullptr;
 }
 
+Error Request::ReceiveMetaData() {
+    if (request_header_.meta_size == 0) {
+        return nullptr;
+    }
+
+    Error err;
+    auto buf = std::unique_ptr<uint8_t[]> {new uint8_t[(size_t)request_header_.meta_size]};
+    io__->Receive(socket_fd_, (void*) buf.get(), (size_t) request_header_.meta_size, &err);
+    if (err) {
+        return err;
+    }
+    metadata_.assign((char*)buf.get());
+    return nullptr;
+}
+
+
 Error Request::ReceiveData() {
+    if (request_header_.data_size == 0) {
+        return nullptr;
+    }
+
     auto err = PrepareDataBuffer();
     if (err) {
         return err;
@@ -44,16 +64,31 @@ Error Request::ReceiveData() {
 }
 
 
+Error Request::ReceiveRequestContent(ReceiverStatistics* statistics) {
+    statistics->StartTimer(StatisticEntity::kNetwork);
+    auto err = ReceiveData();
+    if (err) {
+        return err;
+    }
+
+    err = ReceiveMetaData();
+    if (err) {
+        return err;
+    }
+
+    statistics->StopTimer();
+
+    return nullptr;
+}
+
+
+
 Error Request::Handle(ReceiverStatistics* statistics) {
-    Error err;
-    if (request_header_.data_size != 0) {
-        statistics->StartTimer(StatisticEntity::kNetwork);
-        auto err = ReceiveData();
-        if (err) {
-            return err;
-        }
-        statistics->StopTimer();
+    auto err = ReceiveRequestContent(statistics);
+    if (err) {
+        return err;
     }
+
     for (auto handler : handlers_) {
         statistics->StartTimer(handler->GetStatisticEntity());
         auto err = handler->ProcessRequest(this);
@@ -136,4 +171,9 @@ uint64_t Request::GetSlotId() const {
         return 0;
     }
 }
+
+const std::string& Request::GetMetaData() const {
+    return metadata_;
+}
+
 }
\ No newline at end of file

receiver/src/request.h

@@ -37,6 +37,7 @@ class Request {
     VIRTUAL const char* GetMessage() const;
 
     const std::string& GetOriginUri() const;
+    VIRTUAL const std::string& GetMetaData() const;
     VIRTUAL const std::string& GetBeamtimeId() const;
     VIRTUAL void SetBeamtimeId(std::string beamtime_id);
     VIRTUAL void SetBeamline(std::string beamline);
@@ -47,6 +48,9 @@ class Request {
   private:
     Error PrepareDataBuffer();
     Error ReceiveData();
+    Error ReceiveMetaData();
+    Error ReceiveRequestContent(ReceiverStatistics* statistics);
+
     const GenericRequestHeader request_header_;
     const SocketDescriptor socket_fd_;
     FileData data_buffer_;
@@ -55,6 +59,7 @@ class Request {
     std::string origin_uri_;
     std::string beamtime_id_;
     std::string beamline_;
+    std::string metadata_;
     CacheMeta* slot_meta_ = nullptr;
 };
 

receiver/unittests/test_request.cpp

@@ -68,6 +68,8 @@ class RequestTests : public Test {
     uint64_t data_id_{15};
     uint64_t expected_slot_id{16};
     std::string expected_origin_uri = "origin_uri";
+    std::string expected_metadata = "meta";
+    uint64_t expected_metadata_size = expected_metadata.size();
     asapo::Opcode expected_op_code = asapo::kOpcodeTransferData;
     char expected_request_message[asapo::kMaxMessageSize] = "test_message";
     std::unique_ptr<Request> request;
@@ -79,6 +81,7 @@ class RequestTests : public Test {
         stat = &mock_statistics;
         generic_request_header.data_size = data_size_;
         generic_request_header.data_id = data_id_;
+        generic_request_header.meta_size = expected_metadata_size;
         generic_request_header.op_code = expected_op_code;
         strcpy(generic_request_header.message, expected_request_message);
         request.reset(new Request{generic_request_header, socket_fd_, expected_origin_uri, nullptr});
@@ -92,12 +95,45 @@ class RequestTests : public Test {
         request->io__.release();
     }
     void ExpectFileName(std::string sended, std::string received);
+    void ExpectReceive(uint64_t expected_size, bool ok = true);
+    void ExpectReceiveData(bool ok = true);
+    void ExpectReceiveMetaData(bool ok = true);
+    void ExpectReceiveAllOK();
 
 
 };
 
+ACTION_P(CopyStr,value) {
+    if (value.size()<=arg2) {
+        strcpy(static_cast<char*>(arg1), value.c_str());
+    }
+}
+
+
+void RequestTests::ExpectReceive(uint64_t expected_size,bool ok) {
+    EXPECT_CALL(mock_io, Receive_t(socket_fd_, _, expected_size, _)).WillOnce(
+        DoAll(
+              CopyStr(expected_metadata),
+              SetArgPointee<3>(ok?nullptr:new asapo::IOError("Test Read Error", asapo::IOErrorType::kReadError)),
+              Return(0)
+        ));
+
+}
+void RequestTests::ExpectReceiveData(bool ok) {
+    ExpectReceive(data_size_,ok);
+}
+void RequestTests::ExpectReceiveMetaData(bool ok) {
+    ExpectReceive(expected_metadata_size,ok);
+}
+
+void RequestTests::ExpectReceiveAllOK() {
+    ExpectReceiveData(true);
+    ExpectReceiveMetaData(true);
+}
+
 TEST_F(RequestTests, HandleDoesNotReceiveEmptyData) {
     generic_request_header.data_size = 0;
+    generic_request_header.meta_size = 0;
     request->io__.release();
     request.reset(new Request{generic_request_header, socket_fd_, "", nullptr});
     request->io__ = std::unique_ptr<asapo::IO> {&mock_io};;
@@ -110,16 +146,20 @@ TEST_F(RequestTests, HandleDoesNotReceiveEmptyData) {
 }
 
 TEST_F(RequestTests, HandleReturnsErrorOnDataReceive) {
-    EXPECT_CALL(mock_io, Receive_t(socket_fd_, _, data_size_, _)).WillOnce(
-        DoAll(SetArgPointee<3>(new asapo::IOError("Test Read Error", asapo::IOErrorType::kReadError)),
-              Return(0)
-             ));
+    ExpectReceiveData(false);
+    auto err = request->Handle(stat);
+    ASSERT_THAT(err, Eq(asapo::IOErrorTemplates::kReadError));
+}
 
+TEST_F(RequestTests, HandleReturnsErrorOnMetaDataReceive) {
+    ExpectReceiveData(true);
+    ExpectReceiveMetaData(false);
     auto err = request->Handle(stat);
     ASSERT_THAT(err, Eq(asapo::IOErrorTemplates::kReadError));
 }
 
 
+
 TEST_F(RequestTests, HandleGetsMemoryFromCache) {
     request->cache__ = &mock_cache;
     asapo::CacheMeta meta;
@@ -131,7 +171,7 @@ TEST_F(RequestTests, HandleGetsMemoryFromCache) {
 
     EXPECT_CALL(mock_cache, UnlockSlot(&meta));
 
-    auto err = request->Handle(stat);
+    request->Handle(stat);
 
     ASSERT_THAT(request->GetSlotId(), Eq(expected_slot_id));
 }
@@ -154,18 +194,20 @@ TEST_F(RequestTests, ErrorGetMemoryFromCache) {
 }
 
 
-TEST_F(RequestTests, HandleMeasuresTimeOnDataReceive) {
+TEST_F(RequestTests, HandleMeasuresTimeOnContentReceive) {
 
     EXPECT_CALL(mock_statistics, StartTimer_t(asapo::StatisticEntity::kNetwork));
 
-    EXPECT_CALL(mock_io, Receive_t(socket_fd_, _, data_size_, _)).WillOnce(
-        DoAll(SetArgPointee<3>(nullptr),
-              Return(0)
-             ));
+    ExpectReceiveAllOK();
 
     EXPECT_CALL(mock_statistics, StopTimer_t());
 
     request->Handle(stat);
+
+
+    ASSERT_THAT(request->GetMetaData(), Eq(expected_metadata));
+
+
 }
 
 
@@ -257,6 +299,7 @@ void RequestTests::ExpectFileName(std::string sended, std::string received) {
 
 }
 
+
 TEST_F(RequestTests, GetFileName) {
     ExpectFileName("filename.txt", "filename.txt");
 }