mod: RPCRequest sizeable buffer. impr: naming

Author: eigen-value

src/decoder.h

@@ -82,7 +82,7 @@ class RpcDecoder {
         return send(reinterpret_cast<const uint8_t*>(packer.data()), packer.size()) == packer.size();
     }
 
-    MsgPack::str_t fetch_method(){
+    MsgPack::str_t fetch_rpc_method(){
 
         if (!packet_incoming()){return "";}
 

src/request.h

@@ -1,23 +1,84 @@
 #ifndef RPCLITE_REQUEST_H
 #define RPCLITE_REQUEST_H
 
-#define RPC_BUFFER_SIZE  1024
+#define DEFAULT_RPC_BUFFER_SIZE  256
 
 
 #include "rpclite_utils.h"
 
+template<size_t BufferSize = DEFAULT_RPC_BUFFER_SIZE>
 class RPCRequest {
 
 public:
-    uint8_t buffer[RPC_BUFFER_SIZE];
+    uint8_t buffer[BufferSize];
     size_t size = 0;
     int type = NO_MSG;
-    MsgPack::Packer res_packer;
+    uint32_t msg_id = 0;
+    MsgPack::str_t method;
+    MsgPack::Packer packer;
+    MsgPack::Unpacker unpacker;
+
+    // void print(){
+
+    //     Serial.print("internal buffer ");
+    //     for (size_t i=0; i<size; i++){
+    //         Serial.print(buffer[i], HEX);
+    //     }
+    //     Serial.println("");
+    // }
+
+    size_t get_buffer_size() const {
+        return BufferSize;
+    }
+
+    bool unpack_request_headers(){
+        if (size == 0) return false;
+
+        unpacker.clear();
+        if (!unpacker.feed(buffer, size)) return false;
+
+        int msg_type;
+        uint32_t req_id;
+        MsgPack::str_t req_method;
+        MsgPack::arr_size_t req_size;
+
+        if (!unpacker.deserialize(req_size, msg_type)) {
+            return false; // Header not unpackable
+        }
+
+        if (msg_type == CALL_MSG && req_size.size() == REQUEST_SIZE) {
+            if (!unpacker.deserialize(req_id, req_method)) {
+                return false; // Method not unpackable
+            }
+        } else if (msg_type == NOTIFY_MSG && req_size.size() == NOTIFY_SIZE) {
+            if (!unpacker.deserialize(req_method)) {
+                return false; // Method not unpackable
+            }
+        } else {
+            return false; // Invalid request size/type
+        }
+
+        method = req_method;
+        type = msg_type;
+        msg_id = req_id;
+
+        return true;
+
+    }
+
+    void pack_response_headers(){
+        packer.clear();
+        MsgPack::arr_size_t resp_size(RESPONSE_SIZE);
+        if (type == CALL_MSG) packer.serialize(resp_size, RESP_MSG, msg_id);
+    }
 
     void reset(){
         size = 0;
         type = NO_MSG;
-        res_packer.clear();
+        msg_id = 0;
+        method = "";
+        unpacker.clear();
+        packer.clear();
     }
 
 };

src/server.h

@@ -33,77 +33,49 @@ class RPCServer {
 
     void run() {
 
-        RPCRequest req;
-        if (get_rpc(req)) {         // Populate local request
-            process_request(req);   // Process local data
-            send_response(req);     // Send from local data
-        }
+        RPCRequest<> req;
+
+        if (!get_rpc(req)) return; // Populate local request
+
+        process_request(req);   // Process local data
+
+        send_response(req);     // Send from local data
 
     }
 
-    bool get_rpc(RPCRequest& req, MsgPack::str_t tag="") {
+    bool get_rpc(RPCRequest<>& req, MsgPack::str_t tag="") {
         decoder->decode();
 
-        MsgPack::str_t method = decoder->fetch_method();
+        MsgPack::str_t method = decoder->fetch_rpc_method();
 
         if (method == "" || !hasTag(method, tag)) return false;
 
-        req.size = decoder->get_request(req.buffer, RPC_BUFFER_SIZE);   // todo overload get_request(RPCRequest& req) so all the request info is in req
+        req.size = decoder->get_request(req.buffer, req.get_buffer_size());   // todo overload get_request(RPCRequest& req) so all the request info is in req
         return req.size > 0;
     }
 
-    void process_request(RPCRequest& req) {
-        if (req.size == 0) return;
-
-        MsgPack::Unpacker unpacker;
-
-        unpacker.clear();
-        if (!unpacker.feed(req.buffer, req.size)) return;
+    void process_request(RPCRequest<>& req) {
 
-        int msg_type;
-        uint32_t msg_id;
-        MsgPack::str_t method;
-        MsgPack::arr_size_t req_size;
-
-        if (!unpacker.deserialize(req_size, msg_type)) {
+        if (!req.unpack_request_headers()) {
             req.reset();
-            return; // Header not unpackable
+            return;
         }
 
-        if (msg_type == CALL_MSG && req_size.size() == REQUEST_SIZE) {
-            if (!unpacker.deserialize(msg_id, method)) {
-                req.reset();
-                return; // Method not unpackable
-            }
-        } else if (msg_type == NOTIFY_MSG && req_size.size() == NOTIFY_SIZE) {
-            if (!unpacker.deserialize(method)) {
-                req.reset();
-                return; // Method not unpackable
-            }
-        } else {
-            req.reset();
-            return; // Invalid request size/type
-        }
-
-        req.type = msg_type;
-
-        MsgPack::arr_size_t resp_size(RESPONSE_SIZE);
-        req.res_packer.clear();
-        if (msg_type == CALL_MSG) req.res_packer.serialize(resp_size, RESP_MSG, msg_id);
+        req.pack_response_headers();
 
-        dispatcher.call(method, unpacker, req.res_packer);
+        dispatcher.call(req.method, req.unpacker, req.packer);
 
     }
 
-    bool send_response(RPCRequest& req) {
+    bool send_response(RPCRequest<>& req) {
 
-        if (req.type == NO_MSG || req.res_packer.size() == 0) {
+        if (req.type == NO_MSG || req.packer.size() == 0) {
             return true; // No response to send
         }
 
         if (req.type == NOTIFY_MSG) return true;
 
-        return decoder->send_response(req.res_packer);
+        return decoder->send_response(req.packer);
 
     }