comparison utilities/vampipe-convert.cpp @ 73:7bfc07576830

Ensure id is passed through properly in convert and in server

 //!!! Lots of potential for refactoring the conversion classes based
 //!!! on the common matter in the following eight functions...
 
 PreservingPluginHandleMapper mapper;
 
+static RequestOrResponse::RpcId
+readJsonId(const Json &j)
+{
+    RequestOrResponse::RpcId id;
+
+    if (j["id"].is_number()) {
+        id.type = RequestOrResponse::RpcId::Number;
+        id.number = j["id"].number_value();
+    } else if (j["id"].is_string()) {
+        id.type = RequestOrResponse::RpcId::Tag;
+        id.tag = j["id"].string_value();
+    } else {
+        id.type = RequestOrResponse::RpcId::Absent;
+    }
+
+    return id;
+}
+
+static Json
+writeJsonId(const RequestOrResponse::RpcId &id)
+{
+    if (id.type == RequestOrResponse::RpcId::Number) {
+        return id.number;
+    } else if (id.type == RequestOrResponse::RpcId::Tag) {
+        return id.tag;
+    } else {
+        return Json();
+    }
+}
+
+template <typename Reader>
+static RequestOrResponse::RpcId
+readCapnpId(const Reader &r)
+{
+    int number;
+    string tag;
+    switch (r.getId().which()) {
+    case RpcRequest::Id::Which::NUMBER:
+        number = r.getId().getNumber();
+        return { RequestOrResponse::RpcId::Number, number, "" };
+    case RpcRequest::Id::Which::TAG:
+        tag = r.getId().getTag();
+        return { RequestOrResponse::RpcId::Tag, 0, tag };
+    case RpcRequest::Id::Which::NONE:
+        return { RequestOrResponse::RpcId::Absent, 0, "" };
+    }
+    return {};
+}
+
+template <typename Builder>
+static void
+buildCapnpId(Builder &b, const RequestOrResponse::RpcId &id)
+{
+    switch (id.type) {
+    case RequestOrResponse::RpcId::Number:
+        b.getId().setNumber(id.number);
+        break;
+    case RequestOrResponse::RpcId::Tag:
+        b.getId().setTag(id.tag);
+        break;
+    case RequestOrResponse::RpcId::Absent:
+        b.getId().setNone();
+        break;
+    }
+}
+
 RequestOrResponse
 readRequestJson(string &err)
 {
     RequestOrResponse rr;
     rr.direction = RequestOrResponse::Request;

     Json j = convertRequestJson(input, err);
     if (err != "") return {};
 
     rr.type = VampJson::getRequestResponseType(j, err);
     if (err != "") return {};
-    
+
+    rr.id = readJsonId(j);
+
     VampJson::BufferSerialisation serialisation =
         VampJson::BufferSerialisation::Array;
 
     switch (rr.type) {
 

     VampJson::BufferSerialisation serialisation =
         (useBase64 ?
          VampJson::BufferSerialisation::Base64 :
          VampJson::BufferSerialisation::Array);
 
+    Json id = writeJsonId(rr.id);
+    
     switch (rr.type) {
 
     case RRType::List:
-	j = VampJson::fromRpcRequest_List();
+	j = VampJson::fromRpcRequest_List(id);
 	break;
     case RRType::Load:
-	j = VampJson::fromRpcRequest_Load(rr.loadRequest);
+	j = VampJson::fromRpcRequest_Load(rr.loadRequest, id);
 	break;
     case RRType::Configure:
-	j = VampJson::fromRpcRequest_Configure(rr.configurationRequest, mapper);
+	j = VampJson::fromRpcRequest_Configure(rr.configurationRequest, mapper, id);
 	break;
     case RRType::Process:
 	j = VampJson::fromRpcRequest_Process
-	    (rr.processRequest, mapper, serialisation);
+	    (rr.processRequest, mapper, serialisation, id);
 	break;
     case RRType::Finish:
-	j = VampJson::fromRpcRequest_Finish(rr.finishRequest, mapper);
+	j = VampJson::fromRpcRequest_Finish(rr.finishRequest, mapper, id);
 	break;
     case RRType::NotValid:
 	break;
     }
 

     Json j = convertResponseJson(input, err);
     if (err != "") return {};
 
     rr.type = VampJson::getRequestResponseType(j, err);
     if (err != "") return {};
+
+    rr.id = readJsonId(j);
     
     VampJson::BufferSerialisation serialisation =
         VampJson::BufferSerialisation::Array;
 
     rr.success = j["success"].bool_value();

     VampJson::BufferSerialisation serialisation =
         (useBase64 ?
          VampJson::BufferSerialisation::Base64 :
          VampJson::BufferSerialisation::Array);
 
+    Json id = writeJsonId(rr.id);
+
     if (!rr.success) {
 
-	j = VampJson::fromError(rr.errorText, rr.type);
+	j = VampJson::fromError(rr.errorText, rr.type, id);
 
     } else {
     
 	switch (rr.type) {
 
 	case RRType::List:
-	    j = VampJson::fromRpcResponse_List(rr.listResponse);
+	    j = VampJson::fromRpcResponse_List(rr.listResponse, id);
 	    break;
 	case RRType::Load:
-	    j = VampJson::fromRpcResponse_Load(rr.loadResponse, mapper);
+	    j = VampJson::fromRpcResponse_Load(rr.loadResponse, mapper, id);
 	    break;
 	case RRType::Configure:
 	    j = VampJson::fromRpcResponse_Configure(rr.configurationResponse,
-                                                     mapper);
+                                                    mapper, id);
 	    break;
 	case RRType::Process:
 	    j = VampJson::fromRpcResponse_Process
-		(rr.processResponse, mapper, serialisation);
+		(rr.processResponse, mapper, serialisation, id);
 	    break;
 	case RRType::Finish:
 	    j = VampJson::fromRpcResponse_Finish
-		(rr.finishResponse, mapper, serialisation);
+		(rr.finishResponse, mapper, serialisation, id);
 	    break;
 	case RRType::NotValid:
 	    break;
 	}
     }

 
     ::capnp::InputStreamMessageReader message(buffered);
     RpcRequest::Reader reader = message.getRoot<RpcRequest>();
     
     rr.type = VampnProto::getRequestResponseType(reader);
+    rr.id = readCapnpId(reader);
 
     switch (rr.type) {
 
     case RRType::List:
 	VampnProto::readRpcRequest_List(reader); // type check only

 writeRequestCapnp(RequestOrResponse &rr)
 {
     ::capnp::MallocMessageBuilder message;
     RpcRequest::Builder builder = message.initRoot<RpcRequest>();
 
+    buildCapnpId(builder, rr.id);
+    
     switch (rr.type) {
 
     case RRType::List:
 	VampnProto::buildRpcRequest_List(builder);
 	break;

     RpcResponse::Reader reader = message.getRoot<RpcResponse>();
     
     rr.type = VampnProto::getRequestResponseType(reader);
     rr.success = true;
     rr.errorText = "";
+    rr.id = readCapnpId(reader);
     int errorCode = 0;
 
     switch (rr.type) {
 
     case RRType::List:

 void
 writeResponseCapnp(RequestOrResponse &rr)
 {
     ::capnp::MallocMessageBuilder message;
     RpcResponse::Builder builder = message.initRoot<RpcResponse>();
+
+    buildCapnpId(builder, rr.id);
 
     if (!rr.success) {
 
 	VampnProto::buildRpcResponse_Error(builder, rr.errorText, rr.type);