added error types for failing decoding or encoding

NetworkingLib/include/DatagramReceiver.h

@@ -28,10 +28,6 @@ private:
 public:
     using Ptr = std::shared_ptr<DatagramReceiver<Message>>;
 
-    using Udp = boost::asio::ip::udp;
-    using Endpoint = Udp::endpoint;
-    using Socket = Udp::socket;
-
     using ReceiveHandler = std::function<
         void(const error::ErrorCode & error,
              Message & message,
@@ -47,14 +43,14 @@ public:
         : net(net)
           , bindingPort(bindingPort)
           , socket(net.getIoService(), Udp::v4())
-          , buffer(maxMessageSize + internal::Frame::HEADER_SIZE)
+          , buffer(maxMessageSize + Frame::HEADER_SIZE)
     {}
 
     Message receive(std::string & host, std::uint16_t & port, const time::Duration & timeout)
     {
         BusyLock busyLock{*this};
         newSocket();
-        return message::receiveDatagramFrom<Message>(net, socket, buffer, host, port, timeout);
+        return message::receiveDatagram<Message>(net, socket, buffer, host, port, timeout);
     }
 
     void asyncReceive(const time::Duration & timeout, const ReceiveHandler & handler)
@@ -64,7 +60,7 @@ public:
 
         newSocket();
 
-        message::asyncReceiveDatagramFrom<Message>(
+        message::asyncReceiveDatagram<Message>(
             net, socket, buffer, timeout,
             [state](const auto & error,
                     auto & message,
@@ -87,6 +83,11 @@ public:
     }
 
 private:
+    using Udp = boost::asio::ip::udp;
+    using Endpoint = Udp::endpoint;
+    using Socket = Udp::socket;
+    using Frame = networking::internal::Frame;
+
     Networking & net;
     std::uint16_t bindingPort;
     Socket socket;

NetworkingLib/include/DatagramSender.h

@@ -30,9 +30,6 @@ public:
 
     using SendHandler = std::function<void(const error::ErrorCode & error)>;
 
-    using Udp = boost::asio::ip::udp;
-    using Socket = Udp::socket;
-
     static Ptr create(Networking & net)
     {
         return std::make_shared<DatagramSender>(PrivateTag{}, net);
@@ -83,6 +80,9 @@ public:
     }
 
 private:
+    using Udp = boost::asio::ip::udp;
+    using Socket = Udp::socket;
+
     Networking & net;
     Socket socket;
 

NetworkingLib/include/Error.h

@@ -22,6 +22,8 @@ constexpr ErrorCode SUCCESS = ErrorCode{0};
 constexpr ErrorCode FAILED_OPERATION = ErrorCode{1};
 constexpr ErrorCode ABORTED = ErrorCode{2};
 constexpr ErrorCode BUSY = ErrorCode{3};
+constexpr ErrorCode ENCODING = ErrorCode{4};
+constexpr ErrorCode DECODING = ErrorCode{5};
 }
 
 class Error : std::runtime_error
@@ -62,6 +64,22 @@ public:
     {}
 };
 
+class Encoding : public Error
+{
+public:
+    Encoding()
+        : Error("networking error: encoding", codes::ENCODING)
+    {}
+};
+
+class Decoding : public Error
+{
+public:
+    Decoding()
+        : Error("networking error: decoding", codes::DECODING)
+    {}
+};
+
 }
 }
 

NetworkingLib/include/Message.h

@@ -54,17 +54,49 @@ struct Decoder<std::string>
     { return data; }
 };
 
+namespace internal
+{
+
+template<typename Message>
+bool encode(const Message & message, std::string & data)
+{
+    try
+    {
+        data = Encoder<Message>{}(message);
+        return true;
+    }
+    catch (...)
+    {
+        return false;
+    }
+}
+
+template<typename Message>
+bool decode(const std::string & data, Message & message)
+{
+    try
+    {
+        message = Decoder<Message>{}(data);
+        return true;
+    }
+    catch (...)
+    {
+        return false;
+    }
+}
+
+}
+
 template<typename Message>
 void send(Networking & net,
           boost::asio::ip::tcp::socket & socket,
           const Message & message,
           const time::Duration & timeout)
 {
-    using namespace std::chrono_literals;
-    if (timeout <= 0s)
-        throw error::Aborted();
-
-    networking::stream::write(net, socket, Encoder<Message>{}(message), timeout);
+    std::string data{};
+    if (!internal::encode(message, data))
+        throw error::Encoding{};
+    networking::stream::write(net, socket, data, timeout);
 };
 
 template<typename Message>
@@ -74,7 +106,15 @@ void asyncSend(Networking & net,
                const time::Duration & timeout,
                const SendHandler & handler)
 {
-    auto data = std::make_shared<std::string>(Encoder<Message>{}(message));
+    auto data = std::make_shared<std::string>();
+    if (!internal::encode(message, *data))
+    {
+        net.callLater(
+            [handler]
+            { handler(error::codes::ENCODING); });
+        return;
+    }
+
     networking::stream::asyncWrite(
         net, socket, *data, timeout,
         [handler, data](const auto & errorCode)
@@ -87,12 +127,11 @@ Message receive(Networking & net,
                 boost::asio::streambuf & buffer,
                 const time::Duration & timeout)
 {
-    using namespace std::chrono_literals;
-    if (timeout <= 0s)
-        throw error::Aborted();
-
     auto data = networking::stream::read(net, socket, buffer, timeout);
-    return Decoder<Message>{}(data);
+    Message message{};
+    if (!internal::decode(data, message))
+        throw error::Decoding{};
+    return message;
 };
 
 template<typename Message>
@@ -106,7 +145,12 @@ void asyncReceive(Networking & net,
         net, socket, buffer, timeout,
         [handler](const auto & errorCode, auto & data)
         {
-            auto message = Decoder<Message>{}(data);
+            Message message{};
+            if (!internal::decode(data, message))
+            {
+                handler(error::codes::DECODING, message);
+                return;
+            }
             handler(errorCode, message);
         });
 };
@@ -119,7 +163,10 @@ void sendDatagramTo(Networking & net,
                     std::uint16_t port,
                     const time::Duration & timeout)
 {
-    networking::socket::sendTo(net, socket, Encoder<Message>{}(message), host, port, timeout);
+    std::string data{};
+    if (!internal::encode(message, data))
+        throw error::Encoding{};
+    networking::socket::sendTo(net, socket, data, host, port, timeout);
 }
 
 template<typename Message>
@@ -131,7 +178,15 @@ void asyncSendDatagramTo(Networking & net,
                          const time::Duration & timeout,
                          const SendToHandler & handler)
 {
-    auto data = std::make_shared<std::string>(Encoder<Message>{}(message));
+    auto data = std::make_shared<std::string>();
+    if (!internal::encode(message, *data))
+    {
+        net.callLater(
+            [handler]
+            { handler(error::codes::ENCODING); });
+        return;
+    }
+
     networking::socket::asyncSendTo(
         net, socket, *data, host, port, timeout,
         [handler, data](const auto & error)
@@ -139,29 +194,37 @@ void asyncSendDatagramTo(Networking & net,
 }
 
 template<typename Message>
-Message receiveDatagramFrom(Networking & net,
-                            boost::asio::ip::udp::socket & socket,
-                            std::vector<char> & buffer,
-                            std::string & host,
-                            std::uint16_t & port,
-                            const time::Duration & timeout)
+Message receiveDatagram(Networking & net,
+                        boost::asio::ip::udp::socket & socket,
+                        std::vector<char> & buffer,
+                        std::string & host,
+                        std::uint16_t & port,
+                        const time::Duration & timeout)
 {
     auto data = networking::socket::receiveFrom(net, socket, buffer, host, port, timeout);
-    return Decoder<Message>{}(data);
+    Message message{};
+    if (!internal::decode(data, message))
+        throw error::Decoding{};
+    return message;
 }
 
 template<typename Message>
-void asyncReceiveDatagramFrom(Networking & net,
-                              boost::asio::ip::udp::socket & socket,
-                              std::vector<char> & buffer,
-                              const time::Duration & timeout,
-                              const ReceiveFromHandler<Message> & handler)
+void asyncReceiveDatagram(Networking & net,
+                          boost::asio::ip::udp::socket & socket,
+                          std::vector<char> & buffer,
+                          const time::Duration & timeout,
+                          const ReceiveFromHandler<Message> & handler)
 {
     networking::socket::asyncReceiveFrom(
         net, socket, buffer, timeout,
         [handler](auto error, auto & data, const auto & senderHost, auto senderPort)
         {
-            auto message = Decoder<Message>{}(data);
+            Message message{};
+            if (!internal::decode(data, message))
+            {
+                handler(error::codes::DECODING, message, senderHost, senderPort);
+                return;
+            }
             handler(error, message, senderHost, senderPort);
         });
 }

NetworkingLib/include/Resolver.h

@@ -81,9 +81,6 @@ public:
 
     using Ptr = std::shared_ptr<Resolver>;
 
-    using Protocol = boost::asio::ip::tcp;
-    using UnderlyingResolver = internal::CloseableResolver<Protocol>;
-
     using ResolveHandler = std::function<void(const error::ErrorCode & error, const std::vector<Endpoint> & endpoints)>;
 
     static Ptr create(Networking & net)
@@ -162,6 +159,9 @@ public:
     }
 
 private:
+    using Protocol = boost::asio::ip::tcp;
+    using UnderlyingResolver = internal::CloseableResolver<Protocol>;
+
     Networking & net;
     UnderlyingResolver resolver;
 

NetworkingLib/include/ServiceClient.h

@@ -37,8 +37,6 @@ public:
     using RequestMessage = typename Service::RequestMessage;
     using ResponseMessage = typename Service::ResponseMessage;
 
-    using Socket = typename boost::asio::ip::tcp::socket;
-
     using CallHandler = std::function<void(const error::ErrorCode & error, ResponseMessage & response)>;
 
     static Ptr create(Networking & net, std::size_t maxMessageSize = 512)
@@ -140,6 +138,9 @@ public:
     }
 
 private:
+    using Socket = boost::asio::ip::tcp::socket;
+    using Frame = networking::internal::Frame;
+
     networking::Networking & net;
     Socket socket;
     const std::size_t maxMessageSize;
@@ -170,7 +171,7 @@ private:
               , handler(handler)
               , timeout(timeout)
               , startTime(startTime)
-              , buffer(self->maxMessageSize + internal::Frame::HEADER_SIZE)
+              , buffer(self->maxMessageSize + Frame::HEADER_SIZE)
               , closer(self->socket)
         {}
 

NetworkingLib/include/ServiceServer.h

@@ -27,10 +27,6 @@ public:
 
     using Ptr = std::shared_ptr<Server<Service>>;
 
-    using Tcp = boost::asio::ip::tcp;
-    using Socket = Tcp::socket;
-    using Acceptor = Tcp::acceptor;
-
     using Endpoint = Resolver::Endpoint;
 
     using RequestReceivedHandler =
@@ -70,6 +66,11 @@ public:
     }
 
 private:
+    using Tcp = boost::asio::ip::tcp;
+    using Socket = Tcp::socket;
+    using Acceptor = Tcp::acceptor;
+    using Frame = networking::internal::Frame;
+
     Networking & net;
     std::uint16_t bindingPort;
     Acceptor acceptor;

Protocol/CMakeLists.txt

@@ -23,7 +23,20 @@ find_package(NetworkingLib REQUIRED)
 #########################
 # Protocol Library Target
 #########################
-set(SOURCE_FILES include/Protocol.h include/VehicleEndpoint.h src/Vehicle.cpp include/Vehicle.h src/FollowerVehicle.cpp include/FollowerVehicle.h src/LeaderVehicle.cpp include/LeaderVehicle.h include/Utils.h include/PlatoonService.h include/PlatoonMessage.h)
+set(SOURCE_FILES
+        include/Protocol.h
+        include/VehicleEndpoint.h
+        include/Vehicle.h
+        include/FollowerVehicle.h
+        include/LeaderVehicle.h
+        include/Utils.h
+        include/PlatoonService.h
+        include/PlatoonMessage.h
+        include/json.hpp
+        src/LeaderVehicle.cpp
+        src/FollowerVehicle.cpp
+        src/Vehicle.cpp
+        )
 add_library(ProtocolLib ${SOURCE_FILES})
 
 target_link_libraries(ProtocolLib NetworkingLib)