diff --git a/common/cpp/include/system_wrappers/io.h b/common/cpp/include/system_wrappers/io.h
index cb72c12881ff7b968c55021e33d481420b02555b..bf24db4b9f4d47b30ad32c3fe5dfce749fdfa8a1 100644
--- a/common/cpp/include/system_wrappers/io.h
+++ b/common/cpp/include/system_wrappers/io.h
@@ -48,10 +48,13 @@ class IO {
/*
* Network
*/
- virtual FileDescriptor create_socket (AddressFamilies address_family, SocketTypes socket_type, SocketProtocols socket_protocol, IOErrors* err) = 0;
+ virtual FileDescriptor create_socket (AddressFamilies address_family, SocketTypes socket_type,
+ SocketProtocols socket_protocol, IOErrors* err) = 0;
virtual void listen (FileDescriptor socket_fd, int backlog, IOErrors* err) = 0;
- virtual void inet_bind (FileDescriptor socket_fd, const std::string& address, uint16_t port, IOErrors* err) = 0;
- virtual std::unique_ptr<std::tuple<std::string, FileDescriptor>> inet_accept(FileDescriptor socket_fd, IOErrors* err) = 0;
+ virtual void inet_bind (FileDescriptor socket_fd, const std::string& address, uint16_t port,
+ IOErrors* err) = 0;
+ virtual std::unique_ptr<std::tuple<std::string, FileDescriptor>> inet_accept(FileDescriptor socket_fd,
+ IOErrors* err) = 0;
virtual void inet_connect (FileDescriptor socket_fd, const std::string& address, IOErrors* err) = 0;
virtual FileDescriptor create_and_connect_ip_tcp_socket(const std::string& address, IOErrors* err) = 0;
@@ -72,7 +75,7 @@ class IO {
virtual ssize_t deprecated_write (int __fd, const void* __buf, size_t __n) = 0;
// this is not standard function - to be implemented differently in windows and linux
- virtual FileData GetDataFromFile (const std::string &fname, IOErrors* err) = 0;
+ virtual FileData GetDataFromFile (const std::string& fname, IOErrors* err) = 0;
virtual std::vector<FileInfo> FilesInFolder(const std::string& folder, IOErrors* err) = 0;
};
diff --git a/common/cpp/include/system_wrappers/system_io.h b/common/cpp/include/system_wrappers/system_io.h
index ac944b26e09984849a8ef7e71ef71fee6adbbd90..12c4043bb6d00f1a73cbea77256c42525e1b9928 100644
--- a/common/cpp/include/system_wrappers/system_io.h
+++ b/common/cpp/include/system_wrappers/system_io.h
@@ -11,7 +11,8 @@ class SystemIO final : public IO {
/*
* Network
*/
- FileDescriptor create_socket (AddressFamilies address_family, SocketTypes socket_type, SocketProtocols socket_protocol, IOErrors* err);
+ FileDescriptor create_socket (AddressFamilies address_family, SocketTypes socket_type,
+ SocketProtocols socket_protocol, IOErrors* err);
void listen (FileDescriptor socket_fd, int backlog, IOErrors* err);
void inet_bind (FileDescriptor socket_fd, const std::string& address, uint16_t port, IOErrors* err);
std::unique_ptr<std::tuple<std::string, FileDescriptor>> inet_accept(FileDescriptor socket_fd, IOErrors* err);
@@ -35,7 +36,7 @@ class SystemIO final : public IO {
ssize_t deprecated_write (int __fd, const void* __buf, size_t __n);
// this is not standard function - to be implemented differently in windows and linux
- FileData GetDataFromFile (const std::string &fname, IOErrors* err);
+ FileData GetDataFromFile (const std::string& fname, IOErrors* err);
std::vector<FileInfo> FilesInFolder(const std::string& folder, IOErrors* err);
};
}
diff --git a/common/cpp/src/system_io_linux.cpp b/common/cpp/src/system_io_linux.cpp
index 705de99fe41f307134cece3b3c3c54c68d203218..18cc744ac7a4db610d8cea960b65015f2de1d98a 100644
--- a/common/cpp/src/system_io_linux.cpp
+++ b/common/cpp/src/system_io_linux.cpp
@@ -53,13 +53,13 @@ IOErrors IOErrorFromErrno() {
sa_family_t AddressFamilyToPosixFamily(AddressFamilies address_family) {
switch(address_family) {
- case AddressFamilies::INET:
- return AF_INET;
+ case AddressFamilies::INET:
+ return AF_INET;
}
return -1;
};
-hidra2::FileData hidra2::SystemIO::GetDataFromFile(const std::string &fname, IOErrors* err) {
+hidra2::FileData hidra2::SystemIO::GetDataFromFile(const std::string& fname, IOErrors* err) {
int fd = deprecated_open(fname.c_str(), O_RDONLY);
*err = IOErrorFromErrno();
if (*err != IOErrors::NO_ERROR) {
@@ -165,9 +165,9 @@ std::vector<FileInfo> SystemIO::FilesInFolder(const string& folder, IOErrors* er
hidra2::FileDescriptor hidra2::SystemIO::create_socket(hidra2::AddressFamilies address_family,
- hidra2::SocketTypes socket_type,
- hidra2::SocketProtocols socket_protocol,
- hidra2::IOErrors* err) {
+ hidra2::SocketTypes socket_type,
+ hidra2::SocketProtocols socket_protocol,
+ hidra2::IOErrors* err) {
*err = IOErrors::NO_ERROR;
int domain = AddressFamilyToPosixFamily(address_family);
@@ -178,22 +178,22 @@ hidra2::FileDescriptor hidra2::SystemIO::create_socket(hidra2::AddressFamilies a
int type = 0;
switch(socket_type) {
- case SocketTypes::STREAM:
- type = SOCK_STREAM;
- break;
- default:
- *err = IOErrors::UNKNOWN_ERROR;//TODO
- return -1;
+ case SocketTypes::STREAM:
+ type = SOCK_STREAM;
+ break;
+ default:
+ *err = IOErrors::UNKNOWN_ERROR;//TODO
+ return -1;
}
int protocol = 0;
switch(socket_protocol) {
- case SocketProtocols::IP:
- protocol = IPPROTO_IP;
- break;
- default:
- *err = IOErrors::UNKNOWN_ERROR;//TODO
- return -1;
+ case SocketProtocols::IP:
+ protocol = IPPROTO_IP;
+ break;
+ default:
+ *err = IOErrors::UNKNOWN_ERROR;//TODO
+ return -1;
}
int fd = ::socket(domain, type, protocol);
@@ -238,8 +238,9 @@ void hidra2::SystemIO::listen(hidra2::FileDescriptor socket_fd, int backlog, hid
*err = IOErrorFromErrno();
}
}
-std::unique_ptr<std::tuple<std::string, hidra2::FileDescriptor>> hidra2::SystemIO::inet_accept(hidra2::FileDescriptor socket_fd,
- IOErrors* err) {
+std::unique_ptr<std::tuple<std::string, hidra2::FileDescriptor>> hidra2::SystemIO::inet_accept(
+ hidra2::FileDescriptor socket_fd,
+IOErrors* err) {
sa_family_t family = AddressFamilyToPosixFamily(AddressFamilies::INET);
if(family == -1) {
*err = IOErrors::UNSUPPORTED_ADDRESS_FAMILY;
@@ -257,7 +258,8 @@ std::unique_ptr<std::tuple<std::string, hidra2::FileDescriptor>> hidra2::SystemI
}
std::string address = std::string(inet_ntoa(client_address.sin_addr)) + ':' + std::to_string(client_address.sin_port);
- return std::unique_ptr<std::tuple<std::string, hidra2::FileDescriptor>>(new std::tuple<std::string, hidra2::FileDescriptor>(address, peer_fd));
+ return std::unique_ptr<std::tuple<std::string, hidra2::FileDescriptor>>(new
+ std::tuple<std::string, hidra2::FileDescriptor>(address, peer_fd));
}
void hidra2::SystemIO::inet_connect(FileDescriptor socket_fd, const std::string& address, hidra2::IOErrors* err) {
@@ -270,8 +272,7 @@ void hidra2::SystemIO::inet_connect(FileDescriptor socket_fd, const std::string&
std::string port_str = address.substr(address.find(':') + 1, address.length());
port = static_cast<uint16_t>(std::stoi(port_str));
- }
- catch(std::exception& e) {
+ } catch(std::exception& e) {
*err = IOErrors::INVALID_ADDRESS_FORMAT;
return;
}
@@ -292,7 +293,8 @@ void hidra2::SystemIO::inet_connect(FileDescriptor socket_fd, const std::string&
return;
}
}
-hidra2::FileDescriptor hidra2::SystemIO::create_and_connect_ip_tcp_socket(const std::string& address, hidra2::IOErrors* err) {
+hidra2::FileDescriptor hidra2::SystemIO::create_and_connect_ip_tcp_socket(const std::string& address,
+ hidra2::IOErrors* err) {
*err = hidra2::IOErrors::NO_ERROR;
FileDescriptor fd = create_socket(AddressFamilies::INET, SocketTypes::STREAM, SocketProtocols::IP, err);
@@ -330,10 +332,10 @@ size_t hidra2::SystemIO::receive(hidra2::FileDescriptor socket_fd, void* buf, si
}
size_t hidra2::SystemIO::receive_timeout(hidra2::FileDescriptor socket_fd,
- void* buf,
- size_t length,
- uint16_t timeout_in_sec,
- hidra2::IOErrors* err) {
+ void* buf,
+ size_t length,
+ uint16_t timeout_in_sec,
+ hidra2::IOErrors* err) {
*err = hidra2::IOErrors::NO_ERROR;
fd_set read_fds;
@@ -342,7 +344,7 @@ size_t hidra2::SystemIO::receive_timeout(hidra2::FileDescriptor socket_fd,
timeout.tv_sec = timeout_in_sec;
timeout.tv_usec = 0;
- int res = select(socket_fd+1, &read_fds, nullptr, nullptr, &timeout);
+ int res = select(socket_fd + 1, &read_fds, nullptr, nullptr, &timeout);
if(res == 0) {
*err = IOErrors::TIMEOUT;
return 0;
diff --git a/producer/api/include/producer/producer.h b/producer/api/include/producer/producer.h
index 2a282f01d15606323b5af8f729a81d88677a16db..9b0ce5fbecea5ebb4a391ee0c54ce7b8cd18eca3 100644
--- a/producer/api/include/producer/producer.h
+++ b/producer/api/include/producer/producer.h
@@ -9,7 +9,7 @@
namespace hidra2 {
enum ProducerError {
- PRODUCER_ERROR__OK,
+ PRODUCER_ERROR__NO_ERROR,
PRODUCER_ERROR__ALREADY_CONNECTED,
PRODUCER_ERROR__CONNECTION_NOT_READY,
PRODUCER_ERROR__SENDING_CHUNK_FAILED,
diff --git a/producer/api/src/producer_impl.cpp b/producer/api/src/producer_impl.cpp
index 19a853ead40709495a6e59fdb7327bc94115d10c..e1a1533efc572d8666eaa51015a674472c110c5d 100644
--- a/producer/api/src/producer_impl.cpp
+++ b/producer/api/src/producer_impl.cpp
@@ -9,6 +9,7 @@
#include "producer_impl.h"
const uint32_t hidra2::ProducerImpl::kVersion = 1;
+const size_t hidra2::ProducerImpl::kMaxChunkSize = (size_t)1024 * (size_t)1024 * (size_t)1024 * (size_t)2; //2GiByte
hidra2::ProducerImpl::ProducerImpl() {
__set_io(ProducerImpl::kDefaultIO);
@@ -19,10 +20,10 @@ uint64_t hidra2::ProducerImpl::get_version() const {
}
hidra2::ProducerStatus hidra2::ProducerImpl::get_status() const {
- return PRODUCER_STATUS__CONNECTED;
+ return status_;
}
-hidra2::ProducerError hidra2::ProducerImpl::initialize_socket_to_receiver_(const std::string &receiver_address) {
+hidra2::ProducerError hidra2::ProducerImpl::initialize_socket_to_receiver_(const std::string& receiver_address) {
IOErrors err;
FileDescriptor fd = io->create_and_connect_ip_tcp_socket(receiver_address, &err);
@@ -34,17 +35,20 @@ hidra2::ProducerError hidra2::ProducerImpl::initialize_socket_to_receiver_(const
}
client_fd_ = fd;
- return PRODUCER_ERROR__OK;
+ return PRODUCER_ERROR__NO_ERROR;
}
hidra2::ProducerError hidra2::ProducerImpl::connect_to_receiver(const std::string& receiver_address) {
- if(client_fd_ != -1) {
+ if(client_fd_ != -1 && status_ != PRODUCER_STATUS__DISCONNECTED && status_ != PRODUCER_STATUS__CONNECTING) {
return PRODUCER_ERROR__ALREADY_CONNECTED;
}
+ status_ = PRODUCER_STATUS__CONNECTING;
+
ProducerError error;
error = initialize_socket_to_receiver_(receiver_address);
if(error) {
+ status_ = PRODUCER_STATUS__DISCONNECTED;
return error;
}
@@ -59,6 +63,7 @@ hidra2::ProducerError hidra2::ProducerImpl::connect_to_receiver(const std::strin
io->send(client_fd_, &helloRequest, sizeof(helloRequest), &io_error);
if(io_error != IOErrors::NO_ERROR) {
std::cerr << "hidra2::ProducerImpl::connect_to_receiver/send error" << std::endl;
+ status_ = PRODUCER_STATUS__DISCONNECTED;
return PRODUCER_ERROR__FAILED_TO_CONNECT_TO_SERVER;
}
@@ -66,6 +71,7 @@ hidra2::ProducerError hidra2::ProducerImpl::connect_to_receiver(const std::strin
io->receive_timeout(client_fd_, &helloResponse, sizeof(helloResponse), 30, &io_error);
if(io_error != IOErrors::NO_ERROR) {
std::cerr << "hidra2::ProducerImpl::connect_to_receiver/receive_timeout error" << std::endl;
+ status_ = PRODUCER_STATUS__DISCONNECTED;
return PRODUCER_ERROR__FAILED_TO_CONNECT_TO_SERVER;
}
@@ -75,22 +81,29 @@ hidra2::ProducerError hidra2::ProducerImpl::connect_to_receiver(const std::strin
std::cout << "server_version: " << helloResponse.server_version << std::endl;
- if(helloResponse.error_code == NET_ERR__NO_ERROR) {
- return PRODUCER_ERROR__OK;
- }
+ if(helloResponse.error_code != NET_ERR__NO_ERROR) {
+ std::cerr << "Fail to connect to server. NetErrorCode: " << helloResponse.error_code << std::endl;
- std::cerr << "Fail to connect to server. NetErrorCode: " << helloResponse.error_code << std::endl;
+ status_ = PRODUCER_STATUS__DISCONNECTED;
+ return PRODUCER_ERROR__FAILED_TO_CONNECT_TO_SERVER;
+ }
- return PRODUCER_ERROR__OK;
+ status_ = PRODUCER_STATUS__CONNECTED;
+ return PRODUCER_ERROR__NO_ERROR;
}
-hidra2::ProducerError hidra2::ProducerImpl::send(std::string filename, void *data, uint64_t file_size) {
+hidra2::ProducerError hidra2::ProducerImpl::send(std::string filename, void* data, uint64_t file_size) {
+ if(status_ != PRODUCER_STATUS__CONNECTED) {
+ return PRODUCER_ERROR__CONNECTION_NOT_READY;
+ }
+ status_ = PRODUCER_STATUS__SENDING;
+
hidra2::PrepareSendDataRequest prepareSendDataRequest;
prepareSendDataRequest.op_code = OP_CODE__PREPARE_SEND_DATA;
prepareSendDataRequest.request_id = request_id++;
prepareSendDataRequest.file_size = file_size;
filename.copy((char*)&prepareSendDataRequest.filename, sizeof(prepareSendDataRequest.filename));
-
+ prepareSendDataRequest.filename[filename.length()] = '\0';
std::cout << "Send file: " << filename << std::endl;
@@ -98,6 +111,7 @@ hidra2::ProducerError hidra2::ProducerImpl::send(std::string filename, void *dat
io->send(client_fd_, &prepareSendDataRequest, sizeof(prepareSendDataRequest), &io_error);
if(io_error != IOErrors::NO_ERROR) {
std::cerr << "hidra2::ProducerImpl::send/send error" << std::endl;
+ status_ = PRODUCER_STATUS__CONNECTED;
return PRODUCER_ERROR__SENDING_SERVER_REQUEST_FAILED;
}
@@ -106,11 +120,13 @@ hidra2::ProducerError hidra2::ProducerImpl::send(std::string filename, void *dat
io->receive_timeout(client_fd_, &prepareSendDataResponse, sizeof(prepareSendDataResponse), 30, &io_error);
if(io_error != IOErrors::NO_ERROR) {
std::cerr << "hidra2::ProducerImpl::send/receive_timeout error" << std::endl;
+ status_ = PRODUCER_STATUS__CONNECTED;
return PRODUCER_ERROR__RECEIVING_SERVER_RESPONSE_FAILED;
}
if(prepareSendDataResponse.error_code) {
std::cerr << "Server rejected metadata. NetErrorCode: " << prepareSendDataResponse.error_code << std::endl;
+ status_ = PRODUCER_STATUS__CONNECTED;
return PRODUCER_ERROR__SERVER_REPORTED_AN_ERROR;
}
std::cout << "op_code: " << prepareSendDataResponse.op_code << std::endl;
@@ -118,14 +134,12 @@ hidra2::ProducerError hidra2::ProducerImpl::send(std::string filename, void *dat
std::cout << "error_code: " << prepareSendDataResponse.error_code << std::endl;
std::cout << "file_reference_id: " << prepareSendDataResponse.file_reference_id << std::endl;
- NetworkErrorCode network_error = NET_ERR__NO_ERROR;
size_t already_send = 0;
- uint64_t max_chunk_size = (uint64_t)1024*(uint64_t)1024*(uint64_t)1024*(uint64_t)2;
- while(!network_error && already_send < file_size) {
- size_t need_to_send = max_chunk_size;
+ while(already_send < file_size) {
+ size_t need_to_send = kMaxChunkSize;
- if(double(file_size) - already_send - max_chunk_size < 0) {
+ if(double(file_size) - already_send - kMaxChunkSize < 0) {
need_to_send = file_size - already_send;
}
@@ -139,12 +153,14 @@ hidra2::ProducerError hidra2::ProducerImpl::send(std::string filename, void *dat
io->send(client_fd_, &sendDataChunkRequest, sizeof(sendDataChunkRequest), &io_error);
if(io_error != IOErrors::NO_ERROR) {
std::cerr << "hidra2::ProducerImpl::send/send2 error" << std::endl;
+ status_ = PRODUCER_STATUS__CONNECTED;
return PRODUCER_ERROR__SENDING_CHUNK_FAILED;
}
io->send(client_fd_, (uint8_t*)data + already_send, need_to_send, &io_error);
if(io_error != IOErrors::NO_ERROR) {
std::cerr << "hidra2::ProducerImpl::send/send3 error" << std::endl;
+ status_ = PRODUCER_STATUS__CONNECTED;
return PRODUCER_ERROR__SENDING_CHUNK_FAILED;
}
@@ -154,15 +170,18 @@ hidra2::ProducerError hidra2::ProducerImpl::send(std::string filename, void *dat
io->receive_timeout(client_fd_, &sendDataChunkResponse, sizeof(sendDataChunkResponse), 30, &io_error);
if(io_error != IOErrors::NO_ERROR) {
std::cerr << "hidra2::ProducerImpl::send/receive_timeout2 error" << std::endl;
+ status_ = PRODUCER_STATUS__CONNECTED;
return PRODUCER_ERROR__RECEIVING_SERVER_RESPONSE_FAILED;
}
if(sendDataChunkResponse.error_code) {
std::cout << "Server reported an error. NetErrorCode: " << sendDataChunkResponse.error_code;
+ status_ = PRODUCER_STATUS__CONNECTED;
return PRODUCER_ERROR__SERVER_REPORTED_AN_ERROR;
}
}
- return PRODUCER_ERROR__OK;
+ status_ = PRODUCER_STATUS__CONNECTED;
+ return PRODUCER_ERROR__NO_ERROR;
}
diff --git a/producer/api/src/producer_impl.h b/producer/api/src/producer_impl.h
index e880dbee6611c556cf1d91a0e89c29b69be68ebb..1ea1eeb9e21ba2d765999d44932f52c7eab58483 100644
--- a/producer/api/src/producer_impl.h
+++ b/producer/api/src/producer_impl.h
@@ -7,18 +7,21 @@
namespace hidra2 {
class ProducerImpl : public Producer {
- friend Producer;
private:
static const uint32_t kVersion;
int client_fd_ = -1;
uint64_t request_id = 0;
- ProducerError initialize_socket_to_receiver_(const std::string &receiver_address);
+ ProducerStatus status_;
+
+ ProducerError initialize_socket_to_receiver_(const std::string& receiver_address);
public:
+ static const size_t kMaxChunkSize;
+
ProducerImpl();
- ProducerImpl(const ProducerImpl &) = delete;
- ProducerImpl &operator=(const ProducerImpl &) = delete;
+ ProducerImpl(const ProducerImpl&) = delete;
+ ProducerImpl& operator=(const ProducerImpl&) = delete;
//~ProducerImpl() override;
uint64_t get_version() const override;
diff --git a/producer/api/unittests/test_producer_impl.cpp b/producer/api/unittests/test_producer_impl.cpp
index 0e769a804829aa26770d2560a7b5d33c56bf97c4..8e68c80cb19644b7bed3a6d241ab6d1f13390a96 100644
--- a/producer/api/unittests/test_producer_impl.cpp
+++ b/producer/api/unittests/test_producer_impl.cpp
@@ -9,19 +9,22 @@ using ::testing::Return;
using ::testing::_;
using ::testing::DoAll;
using ::testing::SetArgReferee;
-//using ::testing::SetArg;
using ::testing::Gt;
+using ::testing::Mock;
+using ::testing::InSequence;
class MockIO : public hidra2::IO {
- public:
+ public:
MOCK_METHOD4(create_socket,
- hidra2::FileDescriptor(hidra2::AddressFamilies address_family, hidra2::SocketTypes socket_type, hidra2::SocketProtocols socket_protocol, hidra2::IOErrors* err));
+ hidra2::FileDescriptor(hidra2::AddressFamilies address_family, hidra2::SocketTypes socket_type,
+ hidra2::SocketProtocols socket_protocol, hidra2::IOErrors* err));
MOCK_METHOD3(listen,
void(hidra2::FileDescriptor socket_fd, int backlog, hidra2::IOErrors* err));
MOCK_METHOD4(inet_bind,
void(hidra2::FileDescriptor socket_fd, const std::string& address, uint16_t port, hidra2::IOErrors* err));
MOCK_METHOD2(inet_accept,
- std::unique_ptr<std::tuple<std::string, hidra2::FileDescriptor>>(hidra2::FileDescriptor socket_fd, hidra2::IOErrors* err));
+ std::unique_ptr<std::tuple<std::string, hidra2::FileDescriptor>>(hidra2::FileDescriptor socket_fd,
+ hidra2::IOErrors* err));
MOCK_METHOD3(inet_connect,
void(hidra2::FileDescriptor socket_fd, const std::string& address, hidra2::IOErrors* err));
MOCK_METHOD2(create_and_connect_ip_tcp_socket,
@@ -41,41 +44,246 @@ class MockIO : public hidra2::IO {
MOCK_METHOD3(deprecated_write,
ssize_t(int __fd, const void* __buf, size_t __n));
MOCK_METHOD2(GetDataFromFile,
- hidra2::FileData(const std::string &fname, hidra2::IOErrors* err));
+ hidra2::FileData(const std::string& fname, hidra2::IOErrors* err));
MOCK_METHOD2(FilesInFolder,
std::vector<hidra2::FileInfo>(const std::string& folder, hidra2::IOErrors* err));
};
+hidra2::ProducerImpl producer;
+uint64_t expected_request_id = 0;
+int expected_fd = 83942;
+
TEST(get_version, VersionAboveZero) {
hidra2::ProducerImpl producer;
EXPECT_GE(producer.get_version(), 0);
}
+TEST(ProducerImpl, get_status__disconnected) {
+ EXPECT_EQ(producer.get_status(), hidra2::PRODUCER_STATUS__DISCONNECTED);
+}
-ACTION(write_hello_reponse_arg1) {
- ((hidra2::HelloResponse*)arg1)->error_code = hidra2::NET_ERR__NO_ERROR;
+TEST(ProducerImpl, send__connection_not_ready) {
+ EXPECT_EQ(producer.send("", nullptr, 1), hidra2::PRODUCER_ERROR__CONNECTION_NOT_READY);
}
-TEST(ProducerImpl, connect_to_receiver) {
+
+/**
+ * connect_to_receiver
+ */
+
+MATCHER_P(M_CheckHelloRequest, request_id, "Checks if a valid HelloRequest was send") {
+ return ((hidra2::HelloRequest*)arg)->op_code == hidra2::OP_CODE__HELLO
+ && ((hidra2::HelloRequest*)arg)->request_id == request_id;
+}
+
+ACTION_P3(A_WriteHelloResponse, error_code, request_id, server_version) {
+ ((hidra2::HelloResponse*)arg1)->op_code = hidra2::OP_CODE__HELLO;
+ ((hidra2::HelloResponse*)arg1)->error_code = error_code;
+ ((hidra2::HelloResponse*)arg1)->request_id = request_id;
+ ((hidra2::HelloResponse*)arg1)->server_version = server_version;
+}
+
+TEST(ProducerImpl, connect_to_receiver__invalid__address_format) {
MockIO mockIO;
+ producer.__set_io(&mockIO);
- hidra2::ProducerImpl producer;
+ std::string expected_address = "127.0.0.1:9090";
+
+ EXPECT_CALL(mockIO, create_and_connect_ip_tcp_socket(expected_address, _))
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<1>(hidra2::IOErrors::INVALID_ADDRESS_FORMAT),
+ Return(-1)
+ ));
+
+ EXPECT_EQ(producer.connect_to_receiver(expected_address), hidra2::PRODUCER_ERROR__INVALID_ADDRESS_FORMAT);
+ EXPECT_EQ(producer.get_status(), hidra2::PRODUCER_STATUS__DISCONNECTED);
+
+ Mock::VerifyAndClearExpectations(&mockIO);
+}
+
+TEST(ProducerImpl, connect_to_receiver__failed_unk) {
+ MockIO mockIO;
producer.__set_io(&mockIO);
std::string expected_address = "127.0.0.1:9090";
- int expected_fd = 83942;
EXPECT_CALL(mockIO, create_and_connect_ip_tcp_socket(expected_address, _))
- .WillOnce(DoAll(testing::SetArgPointee<1>(hidra2::IOErrors::NO_ERROR), Return(expected_fd)));
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<1>(hidra2::IOErrors::UNKNOWN_ERROR),
+ Return(-1)
+ ));
+
+ EXPECT_EQ(producer.connect_to_receiver(expected_address), hidra2::PRODUCER_ERROR__FAILED_TO_CONNECT_TO_SERVER);
+ EXPECT_EQ(producer.get_status(), hidra2::PRODUCER_STATUS__DISCONNECTED);
+
+ Mock::VerifyAndClearExpectations(&mockIO);
+}
+
+TEST(ProducerImpl, connect_to_receiver) {
+ MockIO mockIO;
+ producer.__set_io(&mockIO);
+
+ InSequence sequence;
- EXPECT_CALL(mockIO, send(expected_fd, _/*addr*/, sizeof(hidra2::HelloRequest), _))
- .WillOnce(DoAll(testing::SetArgPointee<3>(hidra2::IOErrors::NO_ERROR), Return(sizeof(hidra2::HelloRequest))));
+ std::string expected_address = "127.0.0.1:9090";
+ EXPECT_CALL(mockIO, create_and_connect_ip_tcp_socket(expected_address, _))
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<1>(hidra2::IOErrors::NO_ERROR),
+ Return(expected_fd)
+ ));
+ EXPECT_CALL(mockIO, send(expected_fd, M_CheckHelloRequest(expected_request_id), sizeof(hidra2::HelloRequest), _))
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<3>(hidra2::IOErrors::NO_ERROR),
+ Return(sizeof(hidra2::HelloRequest))
+ ));
EXPECT_CALL(mockIO, receive_timeout(expected_fd, _/*addr*/, sizeof(hidra2::HelloResponse), Gt(0), _))
- .WillOnce(DoAll(write_hello_reponse_arg1(), testing::SetArgPointee<4>(hidra2::IOErrors::NO_ERROR), Return(sizeof(hidra2::HelloResponse))));
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ A_WriteHelloResponse(hidra2::NET_ERR__NO_ERROR, expected_request_id, 1),
+ testing::SetArgPointee<4>(hidra2::IOErrors::NO_ERROR),
+ Return(sizeof(hidra2::HelloResponse))
+ ));
+
+ expected_request_id++;
+
+ EXPECT_EQ(producer.connect_to_receiver(expected_address), hidra2::PRODUCER_ERROR__NO_ERROR);
+ EXPECT_EQ(producer.get_status(), hidra2::PRODUCER_STATUS__CONNECTED);
+
+ Mock::VerifyAndClearExpectations(&mockIO);
+}
- EXPECT_EQ(producer.connect_to_receiver(expected_address), hidra2::PRODUCER_ERROR__OK);
+TEST(ProducerImpl, connect_to_receiver__already_connected) {
+ EXPECT_EQ(producer.connect_to_receiver(""), hidra2::PRODUCER_ERROR__ALREADY_CONNECTED);
+ EXPECT_EQ(producer.get_status(), hidra2::PRODUCER_STATUS__CONNECTED);
}
+
+/**
+ * send
+ */
+
+MATCHER_P3(M_CheckPrepareSendDataRequest, request_id, filename, file_size,
+ "Checks if a valid PrepareSendDataRequest was send") {
+ return ((hidra2::PrepareSendDataRequest*)arg)->op_code == hidra2::OP_CODE__PREPARE_SEND_DATA
+ && ((hidra2::PrepareSendDataRequest*)arg)->request_id == request_id
+ && strcmp(((hidra2::PrepareSendDataRequest*)arg)->filename, filename.c_str()) == 0
+ && ((hidra2::PrepareSendDataRequest*)arg)->file_size == file_size;
+}
+
+ACTION_P3(A_WritePrepareSendDataResponse, error_code, request_id, file_reference_id) {
+ ((hidra2::PrepareSendDataResponse*)arg1)->op_code = hidra2::OP_CODE__PREPARE_SEND_DATA;
+ ((hidra2::PrepareSendDataResponse*)arg1)->error_code = error_code;
+ ((hidra2::PrepareSendDataResponse*)arg1)->request_id = request_id;
+ ((hidra2::PrepareSendDataResponse*)arg1)->file_reference_id = file_reference_id;
+}
+
+MATCHER_P4(M_CheckSendDataChunkRequest, request_id, file_reference_id, chunk_size, start_byte,
+ "Checks if a valid SendDataChunkRequest was send") {
+ return ((hidra2::SendDataChunkRequest*)arg)->op_code == hidra2::OP_CODE__SEND_DATA_CHUNK
+ && ((hidra2::SendDataChunkRequest*)arg)->request_id == request_id
+ && ((hidra2::SendDataChunkRequest*)arg)->file_reference_id == file_reference_id
+ && ((hidra2::SendDataChunkRequest*)arg)->chunk_size == chunk_size
+ && ((hidra2::SendDataChunkRequest*)arg)->start_byte == start_byte;
+}
+
+ACTION_P2(A_WriteSendDataChunkResponse, error_code, request_id) {
+ ((hidra2::SendDataChunkResponse*)arg1)->op_code = hidra2::OP_CODE__SEND_DATA_CHUNK;
+ ((hidra2::SendDataChunkResponse*)arg1)->error_code = error_code;
+ ((hidra2::SendDataChunkResponse*)arg1)->request_id = request_id;
+}
+
+TEST(ProducerImpl, send) {
+ MockIO mockIO;
+ producer.__set_io(&mockIO);
+
+ InSequence sequence;
+
+ std::string expected_filename = "somefilename.bin";
+ void* expected_file_buffer = (void*)0xC0FFEE;
+ size_t expected_file_size = (size_t)1024 * (size_t)1024 * (size_t)1024 * (size_t)4 + (size_t)300;
+ uint64_t expected_file_ref_id = 1337;
+
+
+ /* PrepareSendDataRequest */
+ EXPECT_CALL(mockIO, send(expected_fd, M_CheckPrepareSendDataRequest(expected_request_id, expected_filename,
+ expected_file_size), sizeof(hidra2::PrepareSendDataRequest), _))
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<3>(hidra2::IOErrors::NO_ERROR),
+ Return(sizeof(hidra2::PrepareSendDataRequest))
+ ));
+
+ /* PrepareSendDataResponse */
+ EXPECT_CALL(mockIO, receive_timeout(expected_fd, _/*addr*/, sizeof(hidra2::PrepareSendDataResponse), Gt(0), _))
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ A_WritePrepareSendDataResponse(hidra2::NET_ERR__NO_ERROR, expected_request_id, expected_file_ref_id),
+ testing::SetArgPointee<4>(hidra2::IOErrors::NO_ERROR),
+ Return(sizeof(hidra2::PrepareSendDataResponse))
+ ));
+
+ expected_request_id++;
+
+
+ size_t already_send = 0;
+
+ while(already_send < expected_file_size) {
+
+ size_t need_to_send = producer.kMaxChunkSize;
+ if(double(expected_file_size) - already_send - producer.kMaxChunkSize < 0) {
+ need_to_send = expected_file_size - already_send;
+ }
+
+ /* SendDataChunkRequest */
+ EXPECT_CALL(mockIO, send(expected_fd, M_CheckSendDataChunkRequest(expected_request_id, expected_file_ref_id,
+ need_to_send, already_send), sizeof(hidra2::SendDataChunkRequest), _))
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<3>(hidra2::IOErrors::NO_ERROR),
+ Return(sizeof(hidra2::SendDataChunkRequest))
+ ));
+
+ EXPECT_CALL(mockIO, send(expected_fd, (uint8_t*)expected_file_buffer + already_send, need_to_send, _))
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ testing::SetArgPointee<3>(hidra2::IOErrors::NO_ERROR),
+ Return(need_to_send)
+ ));
+
+ /* SendDataChunkResponse */
+ EXPECT_CALL(mockIO, receive_timeout(expected_fd, _/*addr*/, sizeof(hidra2::SendDataChunkResponse), Gt(0), _))
+ .Times(1)
+ .WillOnce(
+ DoAll(
+ A_WriteSendDataChunkResponse(hidra2::NET_ERR__NO_ERROR, expected_request_id),
+ testing::SetArgPointee<4>(hidra2::IOErrors::NO_ERROR),
+ Return(sizeof(hidra2::SendDataChunkResponse))
+ ));
+
+ expected_request_id++;
+
+ already_send += need_to_send;
+ }
+
+
+ EXPECT_EQ(producer.send(expected_filename, expected_file_buffer, expected_file_size), hidra2::PRODUCER_ERROR__NO_ERROR);
+
+ Mock::VerifyAndClearExpectations(&mockIO);
+}
+
}
diff --git a/producer/dummy-event-detector-cpp/src/dummy_detector.cpp b/producer/dummy-event-detector-cpp/src/dummy_detector.cpp
index 996d7c1e48c6b86c03f0e0a0250d4ec6fdacb4fd..f8b31d8afa14dd4e37a09346307fab785c6d8ffa 100644
--- a/producer/dummy-event-detector-cpp/src/dummy_detector.cpp
+++ b/producer/dummy-event-detector-cpp/src/dummy_detector.cpp
@@ -6,7 +6,7 @@
#include <cmath>
#include <unistd.h>
-int DummyDetector::main(int argc, char **argv) {
+int DummyDetector::main(int argc, char** argv) {
auto producer = hidra2::Producer::create();
hidra2::ProducerError err = producer->connect_to_receiver("127.0.0.1:8099");
@@ -26,8 +26,8 @@ int DummyDetector::main(int argc, char **argv) {
struct stat astat {};
fstat(fd, &astat);
- size_t map_size = static_cast<size_t>(ceil(float(astat.st_size)/float(getpagesize()))*getpagesize());
- void *buffer = mmap(nullptr, map_size, PROT_READ, MAP_SHARED, fd, 0);
+ size_t map_size = static_cast<size_t>(ceil(float(astat.st_size) / float(getpagesize())) * getpagesize());
+ void* buffer = mmap(nullptr, map_size, PROT_READ, MAP_SHARED, fd, 0);
madvise(buffer, map_size, MADV_SEQUENTIAL | MADV_WILLNEED);
diff --git a/receiver/src/file_refernce_handler.cpp b/receiver/src/file_refernce_handler.cpp
index 72200ef6946c6bf2d84868225e9ff95321d35c4c..52aa818264397b8b35c1bab0cd66c8dcb719bb68 100644
--- a/receiver/src/file_refernce_handler.cpp
+++ b/receiver/src/file_refernce_handler.cpp
@@ -4,13 +4,14 @@
namespace hidra2 {
-std::map<FileReferenceId, std::shared_ptr<FileReferenceHandler::FileInformation>> FileReferenceHandler::kFileRefernceMap;
+std::map<FileReferenceId, std::shared_ptr<FileReferenceHandler::FileInformation>>
+ FileReferenceHandler::kFileRefernceMap;
FileReferenceId FileReferenceHandler::kGlobalFileRefernceId = 0;
hidra2::FileReferenceId FileReferenceHandler::add_file(std::string filename,
- uint64_t file_size,
- uint32_t owner_connection_id,
- FileReferenceHandlerError& err) {
+ uint64_t file_size,
+ uint32_t owner_connection_id,
+ FileReferenceHandlerError& err) {
FileReferenceId file_ref_id = ++kGlobalFileRefernceId;
@@ -39,7 +40,8 @@ hidra2::FileReferenceId FileReferenceHandler::add_file(std::string filename,
return file_ref_id;
}
-std::shared_ptr<FileReferenceHandler::FileInformation> FileReferenceHandler::get_file(FileReferenceId file_reference_id) {
+std::shared_ptr<FileReferenceHandler::FileInformation> FileReferenceHandler::get_file(
+ FileReferenceId file_reference_id) {
return kFileRefernceMap[file_reference_id];
}
diff --git a/receiver/src/file_refernce_handler.h b/receiver/src/file_refernce_handler.h
index f9b19f55a4d7ef7e31a40a6de6ea421a94545336..78f2da8a42c5021cf82cb3886e094d8110e1879f 100644
--- a/receiver/src/file_refernce_handler.h
+++ b/receiver/src/file_refernce_handler.h
@@ -28,7 +28,8 @@ class FileReferenceHandler : HasIO {
static FileReferenceId kGlobalFileRefernceId;
static std::map<FileReferenceId, std::shared_ptr<FileReferenceHandler::FileInformation>> kFileRefernceMap;
public:
- FileReferenceId add_file (std::string filename, uint64_t file_size, uint32_t owner_connection_id, FileReferenceHandlerError& err);
+ FileReferenceId add_file (std::string filename, uint64_t file_size, uint32_t owner_connection_id,
+ FileReferenceHandlerError& err);
std::shared_ptr<FileInformation> get_file (FileReferenceId file_reference_id);
void remove_file (FileReferenceId file_reference_id);
};
diff --git a/receiver/src/network_producer_peer.cpp b/receiver/src/network_producer_peer.cpp
index 3bdab2f75d11835111a8ee123d7a105badda0d15..59865f6b20efee9cc8c8dcd567a11aa0a66a6790 100644
--- a/receiver/src/network_producer_peer.cpp
+++ b/receiver/src/network_producer_peer.cpp
@@ -5,10 +5,11 @@
namespace hidra2 {
FileReferenceHandler NetworkProducerPeer::file_reference_handler;
-const size_t NetworkProducerPeer::kGenericBufferSize = 1024*50;//50KiByte
+const size_t NetworkProducerPeer::kGenericBufferSize = 1024 * 50; //50KiByte
std::atomic<uint32_t> NetworkProducerPeer::kNetworkProducerPeerCount;
-const std::vector<NetworkProducerPeer::RequestHandlerInformation> NetworkProducerPeer::kRequestHandlers = NetworkProducerPeer::init_request_handlers();
+const std::vector<NetworkProducerPeer::RequestHandlerInformation> NetworkProducerPeer::kRequestHandlers =
+ NetworkProducerPeer::init_request_handlers();
NetworkProducerPeer::NetworkProducerPeer(int socket_fd, std::string address) : HasIO() {
address_ = std::move(address);
@@ -111,9 +112,11 @@ size_t NetworkProducerPeer::handle_generic_request_(GenericNetworkRequest* reque
IOErrors err;
//receive the rest of the message
- io->receive_timeout(socket_fd_, request->data, handler_information.request_size - sizeof(GenericNetworkRequest), 30, &err);
+ io->receive_timeout(socket_fd_, request->data, handler_information.request_size - sizeof(GenericNetworkRequest), 30,
+ &err);
if(err != IOErrors::NO_ERROR) {
- std::cerr << "[" << connection_id() << "] NetworkProducerPeer::handle_generic_request_/receive_timeout: " << request->op_code << std::endl;
+ std::cerr << "[" << connection_id() << "] NetworkProducerPeer::handle_generic_request_/receive_timeout: " <<
+ request->op_code << std::endl;
return 0;
}
diff --git a/receiver/src/network_producer_peer.h b/receiver/src/network_producer_peer.h
index 5ce160cf640a6de05a94046b90ac1acae8f0c480..9d50c6a1983c66ea839067745f74d8f6b56dd75c 100644
--- a/receiver/src/network_producer_peer.h
+++ b/receiver/src/network_producer_peer.h
@@ -16,7 +16,8 @@ namespace hidra2 {
class NetworkProducerPeer : HasIO {
public:
- typedef void (*RequestHandler) (NetworkProducerPeer* self, GenericNetworkRequest* request, GenericNetworkResponse* response);
+ typedef void (*RequestHandler) (NetworkProducerPeer* self, GenericNetworkRequest* request,
+ GenericNetworkResponse* response);
struct RequestHandlerInformation {
size_t request_size;
size_t response_size;
@@ -43,11 +44,13 @@ class NetworkProducerPeer : HasIO {
size_t handle_generic_request_(GenericNetworkRequest* request, GenericNetworkResponse* response);
static void handle_hello_request_(NetworkProducerPeer* self, const HelloRequest* request, HelloResponse* response);
- static void handle_prepare_send_data_request_(NetworkProducerPeer* self, const PrepareSendDataRequest* request, PrepareSendDataResponse* response);
- static void handle_send_data_chunk_request_(NetworkProducerPeer* self, const SendDataChunkRequest* request, SendDataChunkResponse* response);
+ static void handle_prepare_send_data_request_(NetworkProducerPeer* self, const PrepareSendDataRequest* request,
+ PrepareSendDataResponse* response);
+ static void handle_send_data_chunk_request_(NetworkProducerPeer* self, const SendDataChunkRequest* request,
+ SendDataChunkResponse* response);
public:
- NetworkProducerPeer &operator=(const NetworkProducerPeer &) = delete;
+ NetworkProducerPeer& operator=(const NetworkProducerPeer&) = delete;
NetworkProducerPeer() = default;
NetworkProducerPeer(int socket_fd, std::string address);
diff --git a/receiver/src/network_producer_peer_handlers.cpp b/receiver/src/network_producer_peer_handlers.cpp
index 6abf14f704b05a0437bf2004a317e7be5adde1ea..94dff6c47928bb65630f91d820d5c9ee60e67ae1 100644
--- a/receiver/src/network_producer_peer_handlers.cpp
+++ b/receiver/src/network_producer_peer_handlers.cpp
@@ -13,19 +13,19 @@ const std::vector<NetworkProducerPeer::RequestHandlerInformation> NetworkProduce
vec[OP_CODE__HELLO] = {
sizeof(HelloRequest),
sizeof(HelloResponse),
- (NetworkProducerPeer::RequestHandler) &NetworkProducerPeer::handle_hello_request_
+ (NetworkProducerPeer::RequestHandler)& NetworkProducerPeer::handle_hello_request_
};
vec[OP_CODE__PREPARE_SEND_DATA] = {
sizeof(PrepareSendDataRequest),
sizeof(PrepareSendDataResponse),
- (NetworkProducerPeer::RequestHandler) &NetworkProducerPeer::handle_prepare_send_data_request_
+ (NetworkProducerPeer::RequestHandler)& NetworkProducerPeer::handle_prepare_send_data_request_
};
vec[OP_CODE__SEND_DATA_CHUNK] = {
sizeof(SendDataChunkRequest),
sizeof(SendDataChunkResponse),
- (NetworkProducerPeer::RequestHandler) &NetworkProducerPeer::handle_send_data_chunk_request_
+ (NetworkProducerPeer::RequestHandler)& NetworkProducerPeer::handle_send_data_chunk_request_
};
return vec;
@@ -53,13 +53,14 @@ void NetworkProducerPeer::handle_hello_request_(NetworkProducerPeer* self, const
response->server_version = 1;
}
-void NetworkProducerPeer::handle_prepare_send_data_request_(NetworkProducerPeer* self, const PrepareSendDataRequest* request,
- PrepareSendDataResponse* response) {
+void NetworkProducerPeer::handle_prepare_send_data_request_(NetworkProducerPeer* self,
+ const PrepareSendDataRequest* request,
+ PrepareSendDataResponse* response) {
FileReferenceHandlerError error = FILE_REFERENCE_HANDLER_ERR__OK;
FileReferenceId reference_id = self->file_reference_handler.add_file(request->filename,
- request->file_size,
- self->connection_id(),
- error);
+ request->file_size,
+ self->connection_id(),
+ error);
if(reference_id == 0 || error) {
std::cerr << "Failed to add_file. FileReferenceHandlerError: " << error << std::endl;
@@ -75,8 +76,8 @@ void NetworkProducerPeer::handle_prepare_send_data_request_(NetworkProducerPeer*
}
void NetworkProducerPeer::handle_send_data_chunk_request_(NetworkProducerPeer* self,
- const SendDataChunkRequest* request,
- SendDataChunkResponse* response) {
+ const SendDataChunkRequest* request,
+ SendDataChunkResponse* response) {
IOErrors io_error;
auto file_info = self->file_reference_handler.get_file(request->file_reference_id);
@@ -86,13 +87,15 @@ void NetworkProducerPeer::handle_send_data_chunk_request_(NetworkProducerPeer* s
}
// Round to the next full pagesize
- size_t map_start = size_t(request->start_byte/getpagesize())*getpagesize();
- size_t map_offset = request->start_byte%getpagesize();
- size_t map_size = static_cast<size_t>(ceil(float(request->chunk_size+map_offset)/float(getpagesize()))*getpagesize());
+ size_t map_start = size_t(request->start_byte / getpagesize()) * getpagesize();
+ size_t map_offset = request->start_byte % getpagesize();
+ size_t map_size = static_cast<size_t>(ceil(float(request->chunk_size + map_offset) / float(
+ getpagesize())) * getpagesize());
- if(request->start_byte+request->chunk_size > file_info->file_size) {
+ if(request->start_byte + request->chunk_size > file_info->file_size) {
std::cerr << "Producer is sending a lager file then excepted" << std::endl;
- self->io->receive_timeout(self->socket_fd_, nullptr, request->chunk_size, 30, &io_error);//TODO nullptr not a valid target for receive
+ self->io->receive_timeout(self->socket_fd_, nullptr, request->chunk_size, 30,
+ &io_error);//TODO nullptr not a valid target for receive
return;
}
@@ -104,7 +107,8 @@ void NetworkProducerPeer::handle_send_data_chunk_request_(NetworkProducerPeer* s
if(!mapped_file || mapped_file == MAP_FAILED) {
std::cerr << "Mapping a file failed. errno: " << errno << std::endl;
- self->io->receive_timeout(self->socket_fd_, nullptr, request->chunk_size, 30, &io_error);//TODO nullptr not a valid target for receive
+ self->io->receive_timeout(self->socket_fd_, nullptr, request->chunk_size, 30,
+ &io_error);//TODO nullptr not a valid target for receive
response->error_code = NET_ERR__INTERNAL_SERVER_ERROR;
return;
}
diff --git a/receiver/src/receiver.cpp b/receiver/src/receiver.cpp
index 74256e0ed9c5f502bf802c989ae7deac628c7fa5..08f61d6c54f729606c5819f8e36b2d2fc2b9b92c 100644
--- a/receiver/src/receiver.cpp
+++ b/receiver/src/receiver.cpp
@@ -18,7 +18,8 @@ void hidra2::Receiver::start_listener(std::string listener_address, uint16_t por
IOErrors io_error;
- FileDescriptor listener_fd = io->create_socket(AddressFamilies::INET, SocketTypes::STREAM, SocketProtocols::IP, &io_error);
+ FileDescriptor listener_fd = io->create_socket(AddressFamilies::INET, SocketTypes::STREAM, SocketProtocols::IP,
+ &io_error);
if(io_error != IOErrors::NO_ERROR) {
std::cerr << "Fail to create socket" << std::endl;
return;
diff --git a/receiver/src/receiver.h b/receiver/src/receiver.h
index 892f3ca872f1d698ff12a084dc890a8bea5c6f4b..37b2be88fc452f61094a8e783b7f5137c4593d7a 100644
--- a/receiver/src/receiver.h
+++ b/receiver/src/receiver.h
@@ -28,8 +28,8 @@ class Receiver : HasIO {
std::list<std::unique_ptr<NetworkProducerPeer>> peer_list_;
std::unique_ptr<NetworkProducerPeer> on_new_peer_(int peer_socket_fd, std::string address);
public:
- Receiver(const Receiver &) = delete;
- Receiver &operator=(const Receiver &) = delete;
+ Receiver(const Receiver&) = delete;
+ Receiver& operator=(const Receiver&) = delete;
Receiver() = default;
void start_listener(std::string listener_address, uint16_t port, ReceiverError* err);
diff --git a/worker/api/cpp/src/folder_data_broker.cpp b/worker/api/cpp/src/folder_data_broker.cpp
index 1c4d7e65c990ee8554d6e1a2012f37c364831dd8..e5b0301a5f795b9ab13494f48a544f3c610d3a15 100644
--- a/worker/api/cpp/src/folder_data_broker.cpp
+++ b/worker/api/cpp/src/folder_data_broker.cpp
@@ -7,18 +7,18 @@ namespace hidra2 {
WorkerErrorCode MapIOError(IOErrors io_err) {
WorkerErrorCode err;
switch (io_err) { // we do not use map due to performance reasons
- case IOErrors::NO_ERROR:
- err = WorkerErrorCode::OK;
- break;
- case IOErrors::FILE_NOT_FOUND:
- err = WorkerErrorCode::SOURCE_NOT_FOUND;
- break;
- case IOErrors::PERMISSIONS_DENIED:
- err = WorkerErrorCode::PERMISSIONS_DENIED;
- break;
- case IOErrors::READ_ERROR:
- err = WorkerErrorCode::ERROR_READING_FROM_SOURCE;
- break;
+ case IOErrors::NO_ERROR:
+ err = WorkerErrorCode::OK;
+ break;
+ case IOErrors::FILE_NOT_FOUND:
+ err = WorkerErrorCode::SOURCE_NOT_FOUND;
+ break;
+ case IOErrors::PERMISSIONS_DENIED:
+ err = WorkerErrorCode::PERMISSIONS_DENIED;
+ break;
+ case IOErrors::READ_ERROR:
+ err = WorkerErrorCode::ERROR_READING_FROM_SOURCE;
+ break;
default:
err = WorkerErrorCode::UNKNOWN_IO_ERROR;
break;
@@ -78,8 +78,8 @@ WorkerErrorCode FolderDataBroker::GetNext(FileInfo* info, FileData* data) {
IOErrors ioerr;
*data = io__->GetDataFromFile(base_path_ + "/" + info->relative_path +
- (info->relative_path.empty() ? "" : "/") +
- info->base_name, &ioerr);
+ (info->relative_path.empty() ? "" : "/") +
+ info->base_name, &ioerr);
return MapIOError(ioerr);
}
diff --git a/worker/api/cpp/unittests/test_folder_broker.cpp b/worker/api/cpp/unittests/test_folder_broker.cpp
index 353e50cae12b0e96e1bfa7c58056e8e933ac00cd..763316c29848ff3e35c9b08d60642eaae5ed01ce 100644
--- a/worker/api/cpp/unittests/test_folder_broker.cpp
+++ b/worker/api/cpp/unittests/test_folder_broker.cpp
@@ -36,7 +36,7 @@ TEST(FolderDataBroker, SetCorrectIO) {
class FakeIO: public IO {
public:
- FileData GetDataFromFile(const std::string &fname, IOErrors* err) {
+ FileData GetDataFromFile(const std::string& fname, IOErrors* err) {
*err = IOErrors::NO_ERROR;
return {};
};
@@ -95,7 +95,7 @@ class IOEmptyFodler: public FakeIO {
class IOCannotOpenFile: public FakeIO {
public:
- FileData GetDataFromFile(const std::string &fname, IOErrors* err) {
+ FileData GetDataFromFile(const std::string& fname, IOErrors* err) {
*err = IOErrors::PERMISSIONS_DENIED;
return {};
};
@@ -229,11 +229,11 @@ TEST_F(FolderDataBrokerTests, GetNextReturnsData) {
FileData data;
EXPECT_CALL(mock, GetDataFromFile(_, _)).
- WillOnce(DoAll(testing::SetArgPointee<1>(IOErrors::NO_ERROR), testing::Return(FileData{'1'})));
+ WillOnce(DoAll(testing::SetArgPointee<1>(IOErrors::NO_ERROR), testing::Return(FileData{'1'})));
data_broker->GetNext(&fi, &data);
data_broker->io__.release();
- ASSERT_THAT(data[0],Eq('1'));
+ ASSERT_THAT(data[0], Eq('1'));
}
@@ -245,11 +245,11 @@ TEST_F(FolderDataBrokerTests, GetNextReturnsErrorWhenCannotReadData) {
FileData data;
EXPECT_CALL(mock, GetDataFromFile(_, _)).
- WillOnce(DoAll(testing::SetArgPointee<1>(IOErrors::READ_ERROR), testing::Return(FileData{})));
+ WillOnce(DoAll(testing::SetArgPointee<1>(IOErrors::READ_ERROR), testing::Return(FileData{})));
auto err = data_broker->GetNext(&fi, &data);
data_broker->io__.release();
- ASSERT_THAT(err,Eq(WorkerErrorCode::ERROR_READING_FROM_SOURCE));
+ ASSERT_THAT(err, Eq(WorkerErrorCode::ERROR_READING_FROM_SOURCE));
ASSERT_TRUE(data.empty());
}