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

Improve error handling and extend tests for it

         break;
     }
 }
 
 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;
 }
 
 RequestOrResponse
-readResponseJson(string &err)
+readResponseJson(string &err, bool &eof)
 {
     RequestOrResponse rr;
     rr.direction = RequestOrResponse::Response;
 
     string input;
     if (!getline(cin, input)) {
         // the EOF case, not actually an error
-        rr.type = RRType::NotValid;
+        eof = true;
         return rr;
     }
 
     Json j = convertResponseJson(input, err);
     if (err != "") return {};

         case RRType::Finish:
             j = VampJson::fromRpcResponse_Finish
                 (rr.finishResponse, mapper, serialisation, id);
             break;
         case RRType::NotValid:
+            j = VampJson::fromError(rr.errorText, rr.type, id);
             break;
         }
     }
     
     cout << j.dump() << endl;

         break;
     case RRType::Finish:
         VampnProto::readRpcResponse_Finish(rr.finishResponse, reader, mapper);
         break;
     case RRType::NotValid:
-        // error
-        rr.success = false;
         VampnProto::readRpcResponse_Error(errorCode, rr.errorText, reader);
         break;
     }
 
     return rr;

             break;
         case RRType::Finish:
             VampnProto::buildRpcResponse_Finish(builder, rr.finishResponse, mapper);
             break;
         case RRType::NotValid:
+            VampnProto::buildRpcResponse_Error(builder, rr.errorText, rr.type);
             break;
         }
     }
     
     writeMessageToFd(1, message);
 }
 
 RequestOrResponse
-readInputJson(RequestOrResponse::Direction direction, string &err)
+readInputJson(RequestOrResponse::Direction direction, string &err, bool &eof)
 {
     if (direction == RequestOrResponse::Request) {
-        return readRequestJson(err);
-    } else {
-        return readResponseJson(err);
+        return readRequestJson(err, eof);
+    } else {
+        return readResponseJson(err, eof);
     }
 }
 
 RequestOrResponse
-readInputCapnp(RequestOrResponse::Direction direction)
+readInputCapnp(RequestOrResponse::Direction direction, bool &eof)
 {
     static kj::FdInputStream stream(0); // stdin
     static kj::BufferedInputStreamWrapper buffered(stream);
 
     if (buffered.tryGetReadBuffer() == nullptr) {
+        eof = true;
         return {};
     }
     
     if (direction == RequestOrResponse::Request) {
         return readRequestCapnp(buffered);

         return readResponseCapnp(buffered);
     }
 }
 
 RequestOrResponse
-readInput(string format, RequestOrResponse::Direction direction)
-{
+readInput(string format, RequestOrResponse::Direction direction, bool &eof)
+{
+    eof = false;
+    
     if (format == "json") {
         string err;
-        auto result = readInputJson(direction, err);
+        auto result = readInputJson(direction, err, eof);
         if (err != "") throw runtime_error(err);
         else return result;
     } else if (format == "capnp") {
-        return readInputCapnp(direction);
+        return readInputCapnp(direction, eof);
     } else {
         throw runtime_error("unknown input format \"" + format + "\"");
     }
 }
 

 
     while (true) {
 
         try {
 
-            RequestOrResponse rr = readInput(informat, direction);
-
-            // NotValid without an exception indicates EOF:
-            if (rr.type == RRType::NotValid) break;
+            bool eof = false;
+            RequestOrResponse rr = readInput(informat, direction, eof);
+            if (eof) break;
 
             writeOutput(outformat, rr);
-            
+
         } catch (std::exception &e) {
 
             cerr << "Error: " << e.what() << endl;
             exit(1);
         }