comparison vamp-server/simple-server.cpp @ 158:0876b5e67afe

Improve error handling and extend tests for it

     }
     return j;
 }
 
 RequestOrResponse
-readRequestJson(string &err)
+readRequestJson(string &err, bool &eof)
 {
     RequestOrResponse rr;
     rr.direction = RequestOrResponse::Request;
 
     string input;
     if (!getline(cin, input)) {
         // the EOF case, not actually an error
-        rr.type = RRType::NotValid;
+        eof = true;
         return rr;
     }
     
     Json j = convertRequestJson(input, err);
     if (err != "") return {};

 
     cout << j.dump() << endl;
 }
 
 void
-writeExceptionJson(const exception &e, RRType type)
-{
-    Json j = VampJson::fromError(e.what(), type, Json());
+writeExceptionJson(const exception &e, RRType type, RequestOrResponse::RpcId id)
+{
+    Json jid = writeJsonId(id);
+    Json j = VampJson::fromError(e.what(), type, jid);
     cout << j.dump() << endl;
 }
 
 RequestOrResponse
-readRequestCapnp()
+readRequestCapnp(bool &eof)
 {
     RequestOrResponse rr;
     rr.direction = RequestOrResponse::Request;
 
     static kj::FdInputStream stream(0); // stdin
     static kj::BufferedInputStreamWrapper buffered(stream);
 
     if (buffered.tryGetReadBuffer() == nullptr) {
-        rr.type = RRType::NotValid;
+        eof = true;
         return rr;
     }
 
     capnp::InputStreamMessageReader message(buffered);
     piper::RpcRequest::Reader reader = message.getRoot<piper::RpcRequest>();

     
     writeMessageToFd(1, message);
 }
 
 void
-writeExceptionCapnp(const exception &e, RRType type)
+writeExceptionCapnp(const exception &e, RRType type, RequestOrResponse::RpcId id)
 {
     capnp::MallocMessageBuilder message;
     piper::RpcResponse::Builder builder = message.initRoot<piper::RpcResponse>();
+
+    buildId(builder, id);
     VampnProto::buildRpcResponse_Exception(builder, e, type);
     
     writeMessageToFd(1, message);
 }
 

         break;
         
     case RRType::Configure:
     {
         auto &creq = request.configurationRequest;
+        if (!creq.plugin) {
+            throw runtime_error("unknown plugin handle supplied to configure");
+        }
+            
         auto h = mapper.pluginToHandle(creq.plugin);
         if (mapper.isConfigured(h)) {
             throw runtime_error("plugin has already been configured");
         }
 

     }
 
     case RRType::Process:
     {
         auto &preq = request.processRequest;
+        if (!preq.plugin) {
+            throw runtime_error("unknown plugin handle supplied to process");
+        }
+
         auto h = mapper.pluginToHandle(preq.plugin);
         if (!mapper.isConfigured(h)) {
             throw runtime_error("plugin has not been configured");
         }
 

     }
 
     case RRType::Finish:
     {
         auto &freq = request.finishRequest;
+        if (!freq.plugin) {
+            throw runtime_error("unknown plugin handle supplied to finish");
+        }
+
         response.finishResponse.plugin = freq.plugin;
 
         auto h = mapper.pluginToHandle(freq.plugin);
         // Finish can be called (to unload the plugin) even if the
         // plugin has never been configured or used. But we want to

     
     return response;
 }
 
 RequestOrResponse
-readRequest(string format)
+readRequest(string format, bool &eof)
 {
     if (format == "capnp") {
-        return readRequestCapnp();
+        return readRequestCapnp(eof);
     } else if (format == "json") {
         string err;
-        auto result = readRequestJson(err);
+        auto result = readRequestJson(err, eof);
         if (err != "") throw runtime_error(err);
         else return result;
     } else {
         throw runtime_error("unknown input format \"" + format + "\"");
     }

     }
     suspendOutput();
 }
 
 void
-writeException(string format, const exception &e, RRType type)
+writeException(string format, const exception &e, RRType type, RequestOrResponse::RpcId id)
 {
     resumeOutput();
     if (format == "capnp") {
-        writeExceptionCapnp(e, type);
+        writeExceptionCapnp(e, type, id);
     } else if (format == "json") {
-        writeExceptionJson(e, type);
+        writeExceptionJson(e, type, id);
     } else {
         throw runtime_error("unknown output format \"" + format + "\"");
     }
     suspendOutput();
 }

 
         RequestOrResponse request;
         
         try {
 
-            request = readRequest(format);
+            bool eof = false;
+            request = readRequest(format, eof);
             
-            // NotValid without an exception indicates EOF:
-            if (request.type == RRType::NotValid) {
+            if (eof) {
                 if (debug) {
                     cerr << myname << " " << pid << ": eof reached, exiting" << endl;
                 }
                 break;
             }

             if (debug) {
                 cerr << myname << " " << pid << ": request received, of type "
                      << int(request.type)
                      << endl;
             }
-
-            RequestOrResponse response = handleRequest(request, debug);
-            response.id = request.id;
-
-            if (debug) {
-                cerr << myname << " " << pid << ": request handled, writing response"
-                     << endl;
-            }
-            
-            writeResponse(format, response);
-
-            if (debug) {
-                cerr << myname << " " << pid << ": response written" << endl;
-            }
-
-            if (request.type == RRType::Finish) {
-                auto h = mapper.pluginToHandle(request.finishRequest.plugin);
-                if (debug) {
-                    cerr << myname << " " << pid << ": deleting the plugin with handle " << h << endl;
-                }
-                mapper.removePlugin(h);
-                delete request.finishRequest.plugin;
-            }
             
         } catch (exception &e) {
 
             if (debug) {
                 cerr << myname << " " << pid << ": error: " << e.what() << endl;
             }
 
-            writeException(format, e, request.type);
+            writeException(format, e, request.type, request.id);
 
             if (format == "capnp") {
                 // Don't try to continue; we can't recover from a
                 // mangled input stream. However, we can return a
                 // successful error code because we are reporting the

                     cerr << myname << " " << pid << ": not attempting to recover from capnp parse problems, exiting" << endl;
                 }
                 exit(0);
             }
         }
+
+        try {
+            RequestOrResponse response = handleRequest(request, debug);
+            response.id = request.id;
+
+            if (debug) {
+                cerr << myname << " " << pid << ": request handled, writing response"
+                     << endl;
+            }
+            
+            writeResponse(format, response);
+
+            if (debug) {
+                cerr << myname << " " << pid << ": response written" << endl;
+            }
+
+            if (request.type == RRType::Finish) {
+                auto h = mapper.pluginToHandle(request.finishRequest.plugin);
+                if (debug) {
+                    cerr << myname << " " << pid << ": deleting the plugin with handle " << h << endl;
+                }
+                mapper.removePlugin(h);
+                delete request.finishRequest.plugin;
+            }
+            
+        } catch (exception &e) {
+
+            if (debug) {
+                cerr << myname << " " << pid << ": error: " << e.what() << endl;
+            }
+
+            writeException(format, e, request.type, request.id);
+        }
     }
 
     exit(0);
 }