feat: add communication interfaces

python/include/communication_interfaces_bindings.hpp

@@ -0,0 +1,8 @@
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+using namespace pybind11::literals;
+
+void bind_tcp(py::module_& m);
+void bind_udp(py::module_& m);
+void bind_zmq(py::module_& m);

python/source/communication_interfaces/bind_tcp.cpp

@@ -0,0 +1,27 @@
+#include "communication_interfaces_bindings.hpp"
+
+#include <communication_interfaces/sockets/TCPClient.hpp>
+#include <communication_interfaces/sockets/TCPServer.hpp>
+
+using namespace communication_interfaces::sockets;
+
+void bind_tcp(py::module_& m) {
+ py::class_<TCPClientConfiguration>(m, "TCPClientConfiguration")
+ .def(
+ py::init<std::string, int, int>(), "TCPClientConfiguration struct", "ip_address"_a, "port"_a, "buffer_size"_a)
+ .def_readwrite("ip_address", &TCPClientConfiguration::ip_address)
+ .def_readwrite("port", &TCPClientConfiguration::port)
+ .def_readwrite("buffer_size", &TCPClientConfiguration::buffer_size);
+
+ py::class_<TCPClient, std::shared_ptr<TCPClient>, ISocket>(m, "TCPClient")
+ .def(py::init<TCPClientConfiguration>(), "Constructor taking the configuration struct", "configuration"_a);
+
+ py::class_<TCPServerConfiguration>(m, "TCPServerConfiguration")
+ .def(py::init<int, int, bool>(), "TCPServerConfiguration struct", "port"_a, "buffer_size"_a, "enable_reuse"_a)
+ .def_readwrite("port", &TCPServerConfiguration::port)
+ .def_readwrite("buffer_size", &TCPServerConfiguration::buffer_size)
+ .def_readwrite("enable_reuse", &TCPServerConfiguration::enable_reuse);
+
+ py::class_<TCPServer, std::shared_ptr<TCPServer>, ISocket>(m, "TCPServer")
+ .def(py::init<TCPServerConfiguration>(), "Constructor taking the configuration struct", "configuration"_a);
+}

python/source/communication_interfaces/bind_udp.cpp

@@ -0,0 +1,24 @@
+#include "communication_interfaces_bindings.hpp"
+
+#include <communication_interfaces/sockets/UDPClient.hpp>
+#include <communication_interfaces/sockets/UDPServer.hpp>
+
+using namespace communication_interfaces::sockets;
+
+void bind_udp(py::module_& m) {
+ py::class_<UDPSocketConfiguration>(m, "UDPSocketConfiguration")
+ .def(
+ py::init<std::string, int, int, bool, double>(), "UDPSocketConfiguration struct", "ip_address"_a, "port"_a,
+ "buffer_size"_a, "enable_reuse"_a = false, "timeout_duration_sec"_a = 0.0)
+ .def_readwrite("ip_address", &UDPSocketConfiguration::ip_address)
+ .def_readwrite("port", &UDPSocketConfiguration::port)
+ .def_readwrite("buffer_size", &UDPSocketConfiguration::buffer_size)
+ .def_readwrite("enable_reuse", &UDPSocketConfiguration::enable_reuse)
+ .def_readwrite("timeout_duration_sec", &UDPSocketConfiguration::timeout_duration_sec);
+
+ py::class_<UDPClient, std::shared_ptr<UDPClient>, ISocket>(m, "UDPClient")
+ .def(py::init<UDPSocketConfiguration>(), "Constructor taking the configuration struct", "configuration"_a);
+
+ py::class_<UDPServer, std::shared_ptr<UDPServer>, ISocket>(m, "UDPServer")
+ .def(py::init<UDPSocketConfiguration>(), "Constructor taking the configuration struct", "configuration"_a);
+}

python/source/communication_interfaces/bind_zmq.cpp

@@ -0,0 +1,87 @@
+#include "communication_interfaces_bindings.hpp"
+
+#include <communication_interfaces/sockets/ZMQPublisherSubscriber.hpp>
+
+using namespace communication_interfaces::sockets;
+
+class PyZMQContext {
+public:
+ PyZMQContext(int io_threads = 1) { context = std::make_shared<zmq::context_t>(io_threads); }
+
+ std::shared_ptr<zmq::context_t> context;
+};
+
+struct PyZMQSocketConfiguration {
+ PyZMQContext context;
+ std::string ip_address;
+ std::string port;
+ bool bind = true;
+ bool wait = false;
+};
+
+struct PyZMQCombinedSocketsConfiguration {
+ PyZMQContext context;
+ std::string ip_address;
+ std::string publisher_port;
+ std::string subscriber_port;
+ bool bind_publisher = true;
+ bool bind_subscriber = true;
+ bool wait = false;
+};
+
+class PyZMQPublisher : public ZMQPublisher, public std::enable_shared_from_this<PyZMQPublisher> {
+public:
+ PyZMQPublisher(PyZMQSocketConfiguration config)
+ : ZMQPublisher({config.context.context, config.ip_address, config.port, config.bind, config.wait}) {}
+};
+
+class PyZMQSubscriber : public ZMQSubscriber, public std::enable_shared_from_this<PyZMQSubscriber> {
+public:
+ PyZMQSubscriber(PyZMQSocketConfiguration config)
+ : ZMQSubscriber({config.context.context, config.ip_address, config.port, config.bind, config.wait}) {}
+};
+
+class PyZMQPublisherSubscriber : public ZMQPublisherSubscriber,
+ public std::enable_shared_from_this<PyZMQPublisherSubscriber> {
+public:
+ PyZMQPublisherSubscriber(PyZMQCombinedSocketsConfiguration config)
+ : ZMQPublisherSubscriber(
+ {config.context.context, config.ip_address, config.publisher_port, config.subscriber_port,
+ config.bind_publisher, config.bind_subscriber, config.wait}) {}
+};
+
+void bind_zmq(py::module_& m) {
+ py::class_<PyZMQContext>(m, "ZMQContext").def(py::init<int>(), "Create a ZMQ context", "io_threads"_a = 1);
+
+ py::class_<PyZMQSocketConfiguration>(m, "ZMQSocketConfiguration")
+ .def(
+ py::init<PyZMQContext, std::string, std::string, bool, bool>(), "ZMQSocketConfiguration struct", "context"_a,
+ "ip_address"_a, "port"_a, "bind"_a = true, "wait"_a = false)
+ .def_readwrite("ip_address", &PyZMQSocketConfiguration::ip_address)
+ .def_readwrite("port", &PyZMQSocketConfiguration::port)
+ .def_readwrite("bind", &PyZMQSocketConfiguration::bind)
+ .def_readwrite("wait", &PyZMQSocketConfiguration::wait);
+
+ py::class_<PyZMQCombinedSocketsConfiguration>(m, "ZMQCombinedSocketsConfiguration")
+ .def(
+ py::init<PyZMQContext, std::string, std::string, std::string, bool, bool, bool>(),
+ "ZMQCombinedSocketsConfiguration struct", "context"_a, "ip_address"_a, "publisher_port"_a,
+ "subscriber_port"_a, "bind_publisher"_a = true, "bind_subscriber"_a = true, "wait"_a = false)
+ .def_readwrite("ip_address", &PyZMQCombinedSocketsConfiguration::ip_address)
+ .def_readwrite("publisher_port", &PyZMQCombinedSocketsConfiguration::publisher_port)
+ .def_readwrite("subscriber_port", &PyZMQCombinedSocketsConfiguration::subscriber_port)
+ .def_readwrite("bind_publisher", &PyZMQCombinedSocketsConfiguration::bind_publisher)
+ .def_readwrite("bind_subscriber", &PyZMQCombinedSocketsConfiguration::bind_subscriber)
+ .def_readwrite("wait", &PyZMQCombinedSocketsConfiguration::wait);
+
+ py::class_<PyZMQPublisher, std::shared_ptr<PyZMQPublisher>, ISocket>(m, "ZMQPublisher")
+ .def(py::init<PyZMQSocketConfiguration>(), "Constructor taking the configuration struct", "configuration"_a);
+
+ py::class_<PyZMQSubscriber, std::shared_ptr<PyZMQSubscriber>, ISocket>(m, "ZMQSubscriber")
+ .def(py::init<PyZMQSocketConfiguration>(), "Constructor taking the configuration struct", "configuration"_a);
+
+ py::class_<PyZMQPublisherSubscriber, std::shared_ptr<PyZMQPublisherSubscriber>, ISocket>(m, "ZMQPublisherSubscriber")
+ .def(
+ py::init<PyZMQCombinedSocketsConfiguration>(), "Constructor taking the configuration struct",
+ "configuration"_a);
+}

python/source/communication_interfaces/communication_interfaces_bindings.cpp

@@ -0,0 +1,46 @@
+#include "communication_interfaces_bindings.hpp"
+
+#include <communication_interfaces/exceptions/SocketConfigurationException.hpp>
+#include <communication_interfaces/sockets/ISocket.hpp>
+
+#define STRINGIFY(x) #x
+#define MACRO_STRINGIFY(x) STRINGIFY(x)
+
+using namespace communication_interfaces;
+
+PYBIND11_MODULE(communication_interfaces, m) {
+ m.doc() = "Python bindings for communication interfaces";
+
+#ifdef MODULE_VERSION_INFO
+ m.attr("__version__") = MACRO_STRINGIFY(MODULE_VERSION_INFO);
+#else
+ m.attr("__version__") = "dev";
+#endif
+
+ auto m_sub_ex = m.def_submodule("exceptions", "Submodule for custom communication interfaces exceptions");
+ py::register_exception<exceptions::SocketConfigurationException>(
+ m_sub_ex, "SocketConfigurationError", PyExc_RuntimeError);
+
+ auto m_sub_sock = m.def_submodule("sockets", "Submodule for communication interfaces sockets");
+
+ py::class_<sockets::ISocket, std::shared_ptr<sockets::ISocket>>(m_sub_sock, "ISocket")
+ .def("open", &sockets::ISocket::open, "Perform configuration steps to open the socket for communication")
+ .def(
+ "receive_bytes",
+ [](sockets::ISocket& socket) -> py::object {
+ std::string buffer;
+ auto res = socket.receive_bytes(buffer);
+ if (res) {
+ return py::bytes(buffer);
+ } else {
+ return py::none();
+ }
+ },
+ "Receive bytes from the socket")
+ .def("send_bytes", &sockets::ISocket::send_bytes, "Receive bytes from the socket", "buffer"_a)
+ .def("close", &sockets::ISocket::close, "Perform steps to disconnect and close the socket communication");
+
+ bind_tcp(m_sub_sock);
+ bind_udp(m_sub_sock);
+ bind_zmq(m_sub_sock);
+}

python/test/communication_interfaces/test_tcp.py

@@ -0,0 +1,56 @@
+import multiprocessing
+import pytest
+import time
+
+from communication_interfaces.exceptions import SocketConfigurationError
+from communication_interfaces.sockets import TCPClientConfiguration, TCPClient, TCPServerConfiguration, TCPServer
+
+
+class TestTCPCommunication:
+ server = TCPServer(TCPServerConfiguration(6000, 50, True))
+ client = TCPClient(TCPClientConfiguration("127.0.0.1", 6000, 50))
+ server_message = "Hello client"
+ client_message = "Hello server"
+
+ def serve(self):
+ self.server.open()
+ response = self.server.receive_bytes()
+ if response is None:
+ pytest.fail("No response from client")
+ assert response.decode("utf-8").rstrip("\x00") == self.client_message
+ assert self.server.send_bytes(self.server_message)
+
+ def test_comm(self):
+ t = multiprocessing.Process(target=self.serve)
+ t.start()
+ time.sleep(1.0)
+
+ self.client.open()
+ assert self.client.send_bytes(self.client_message)
+ response = self.client.receive_bytes()
+ assert response
+ assert response.decode("utf-8").rstrip("\x00") == self.server_message
+
+ buffer = ""
+ self.server.close()
+ with pytest.raises(SocketConfigurationError):
+ self.server.receive_bytes()
+ with pytest.raises(SocketConfigurationError):
+ self.server.send_bytes(buffer)
+ self.client.close()
+ with pytest.raises(SocketConfigurationError):
+ self.client.receive_bytes()
+ with pytest.raises(SocketConfigurationError):
+ self.client.send_bytes(buffer)
+
+ def test_not_open(self):
+ buffer = ""
+ with pytest.raises(SocketConfigurationError):
+ self.server.receive_bytes()
+ with pytest.raises(SocketConfigurationError):
+ self.server.send_bytes(buffer)
+
+ with pytest.raises(SocketConfigurationError):
+ self.client.receive_bytes()
+ with pytest.raises(SocketConfigurationError):
+ self.client.send_bytes(buffer)

python/test/communication_interfaces/test_udp.py

@@ -0,0 +1,94 @@
+import pytest
+
+from communication_interfaces.sockets import UDPSocketConfiguration, UDPClient, UDPServer
+from communication_interfaces.exceptions import SocketConfigurationError
+
+
+@pytest.fixture
+def udp_config():
+ return UDPSocketConfiguration("127.0.0.1", 5000, 100)
+
+
+@pytest.fixture
+def server(udp_config):
+ socket = UDPServer(udp_config)
+ yield socket
+ socket.close()
+
+
+@pytest.fixture
+def client(udp_config):
+ socket = UDPClient(udp_config)
+ yield socket
+ socket.close()
+
+
+def test_send_receive(server, client):
+ send_string = "Hello world"
+
+ try:
+ server.open()
+ except SocketConfigurationError as e:
+ pytest.fail(e)
+
+ try:
+ client.open()
+ except SocketConfigurationError as e:
+ pytest.fail(e)
+
+ assert client.send_bytes(send_string)
+ response = server.receive_bytes()
+ assert response
+ assert response.decode("utf-8").rstrip("\x00") == send_string
+
+
+def test_timeout(udp_config):
+ udp_config.timeout_duration_sec = 2.0
+
+ server = UDPServer(udp_config)
+ server.open()
+
+ assert server.receive_bytes() is None
+ server.close()
+
+
+def test_port_reuse(udp_config, server):
+ server.open()
+
+ server2 = UDPServer(udp_config)
+ with pytest.raises(Exception):
+ server2.open()
+
+
+def test_open_close(udp_config):
+ buffer = ""
+ udp_config.timeout_duration_sec = 0.5
+ server = UDPServer(udp_config)
+ with pytest.raises(SocketConfigurationError):
+ server.send_bytes(buffer)
+ with pytest.raises(SocketConfigurationError):
+ server.receive_bytes()
+ server.open()
+ assert server.send_bytes("test")
+ assert not server.receive_bytes()
+
+ server.close()
+ with pytest.raises(SocketConfigurationError):
+ server.send_bytes(buffer)
+ with pytest.raises(SocketConfigurationError):
+ server.receive_bytes()
+
+ client = UDPClient(udp_config)
+ with pytest.raises(SocketConfigurationError):
+ client.send_bytes(buffer)
+ with pytest.raises(SocketConfigurationError):
+ client.receive_bytes()
+ client.open()
+ assert client.send_bytes("test")
+ assert not client.receive_bytes()
+
+ client.close()
+ with pytest.raises(SocketConfigurationError):
+ client.send_bytes(buffer)
+ with pytest.raises(SocketConfigurationError):
+ client.receive_bytes()