c@125: /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
c@125: /*
c@125:     Piper C++
c@125: 
c@125:     An API for audio analysis and feature extraction plugins.
c@125: 
c@125:     Centre for Digital Music, Queen Mary, University of London.
c@125:     Copyright 2006-2016 Chris Cannam and QMUL.
c@125:   
c@125:     Permission is hereby granted, free of charge, to any person
c@125:     obtaining a copy of this software and associated documentation
c@125:     files (the "Software"), to deal in the Software without
c@125:     restriction, including without limitation the rights to use, copy,
c@125:     modify, merge, publish, distribute, sublicense, and/or sell copies
c@125:     of the Software, and to permit persons to whom the Software is
c@125:     furnished to do so, subject to the following conditions:
c@125: 
c@125:     The above copyright notice and this permission notice shall be
c@125:     included in all copies or substantial portions of the Software.
c@125: 
c@125:     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
c@125:     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
c@125:     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
c@125:     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
c@125:     ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
c@125:     CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
c@125:     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
c@125: 
c@125:     Except as contained in this notice, the names of the Centre for
c@125:     Digital Music; Queen Mary, University of London; and Chris Cannam
c@125:     shall not be used in advertising or otherwise to promote the sale,
c@125:     use or other dealings in this Software without prior written
c@125:     authorization.
c@125: */
c@125: 
c@125: #include "vamp-json/VampJson.h"
c@125: #include "vamp-capnp/VampnProto.h"
c@125: #include "vamp-support/RequestOrResponse.h"
c@125: #include "vamp-support/CountingPluginHandleMapper.h"
c@125: #include "vamp-support/LoaderRequests.h"
c@125: 
c@125: #include <iostream>
c@125: #include <sstream>
c@125: #include <stdexcept>
c@125: 
c@125: #include <capnp/serialize.h>
c@125: 
c@125: #include <map>
c@125: #include <set>
c@125: 
c@125: // pid for logging
c@125: #ifdef _WIN32
c@125: #include <process.h>
c@125: static int pid = _getpid();
c@125: #else
c@125: #include <unistd.h>
c@125: static int pid = getpid();
c@125: #endif
c@125: 
c@138: // for _setmode stuff and _dup
c@125: #ifdef _WIN32
c@125: #include <io.h>
c@125: #include <fcntl.h>
c@125: #endif
c@125: 
c@138: // for dup, open etc
c@138: #ifndef _WIN32
c@138: #include <fcntl.h>
c@138: #include <unistd.h>
c@138: #endif
c@138: 
c@125: using namespace std;
c@125: using namespace json11;
c@125: using namespace piper_vamp;
c@125: using namespace Vamp;
c@125: 
c@125: static string myname = "piper-vamp-simple-server";
c@125: 
c@125: static void version()
c@125: {
cannam@272:     cout << "2.0" << endl;
c@125:     exit(0);
c@125: }
c@125: 
c@125: static void usage(bool successful = false)
c@125: {
c@125:     cerr << "\n" << myname <<
c@125:         ": Load & run Vamp plugins in response to Piper messages\n\n"
c@125:         "    Usage: " << myname << " [-d] <format>\n"
c@125:         "           " << myname << " -v\n"
c@125:         "           " << myname << " -h\n\n"
c@125:         "    where\n"
c@125:         "       <format>: the format to read and write messages in (\"json\" or \"capnp\")\n"
cannam@279:         "       -d, --debug: also print debug information to stderr\n"
cannam@279:         "       -v, --version: print version number to stdout and exit\n"
cannam@279:         "       -h, --help: print this text to stderr and exit\n\n"
c@125:         "Expects Piper request messages in either Cap'n Proto or JSON format on stdin,\n"
c@125:         "and writes response messages in the same format to stdout.\n\n"
c@125:         "This server is intended for simple process separation. It's only suitable for\n"
c@125:         "use with a single trusted client per server invocation.\n\n"
c@125:         "The two formats behave differently in case of parser errors. JSON messages are\n"
c@125:         "expected one per input line; because the JSON support is really intended for\n"
c@125:         "interactive troubleshooting, any unparseable message is reported and discarded\n"
c@125:         "and the server waits for another message. In contrast, because of the assumption\n"
c@125:         "that the client is trusted and coupled to the server instance, a mangled\n"
c@125:         "Cap'n Proto message causes the server to exit.\n\n";
c@125:     if (successful) exit(0);
c@125:     else exit(2);
c@125: }
c@125: 
c@125: static CountingPluginHandleMapper mapper;
c@125: 
c@138: // We write our output to stdout, but want to ensure that the plugin
c@138: // doesn't write anything itself. To do this we open a null file
c@138: // descriptor and dup2() it into place of stdout in the gaps between
c@138: // our own output activity.
c@138: 
c@138: static int normalFd = -1;
c@138: static int suspendedFd = -1;
c@138: 
c@138: static void initFds(bool binary)
c@138: {
c@138: #ifdef _WIN32
c@138:     if (binary) {
c@138:         int result = _setmode(0, _O_BINARY);
c@138:         if (result == -1) {
c@138:             throw runtime_error("Failed to set binary mode on stdin");
c@138:         }
c@138:         result = _setmode(1, _O_BINARY);
c@138:         if (result == -1) {
c@138:             throw runtime_error("Failed to set binary mode on stdout");
c@138:         }
c@138:     }
c@138:     normalFd = _dup(1);
c@138:     suspendedFd = _open("NUL", _O_WRONLY);
c@138: #else
c@141:     (void)binary;
c@138:     normalFd = dup(1);
c@138:     suspendedFd = open("/dev/null", O_WRONLY);
c@138: #endif
c@138:     
c@138:     if (normalFd < 0 || suspendedFd < 0) {
c@138:         throw runtime_error("Failed to initialise fds for stdio suspend/resume");
c@138:     }
c@138: }
c@138: 
c@138: static void suspendOutput()
c@138: {
c@138: #ifdef _WIN32
c@138:     _dup2(suspendedFd, 1);
c@138: #else
c@138:     dup2(suspendedFd, 1);
c@138: #endif
c@138: }
c@138: 
c@138: static void resumeOutput()
c@138: {
cannam@262:     fflush(stdout);
c@138: #ifdef _WIN32
c@138:     _dup2(normalFd, 1);
c@138: #else
c@138:     dup2(normalFd, 1);
c@138: #endif
c@138: }
c@138: 
c@125: static RequestOrResponse::RpcId
c@125: readId(const piper::RpcRequest::Reader &r)
c@125: {
c@125:     int number;
c@125:     string tag;
c@125:     switch (r.getId().which()) {
c@125:     case piper::RpcRequest::Id::Which::NUMBER:
c@125:         number = r.getId().getNumber();
c@125:         return { RequestOrResponse::RpcId::Number, number, "" };
c@125:     case piper::RpcRequest::Id::Which::TAG:
c@125:         tag = r.getId().getTag();
c@125:         return { RequestOrResponse::RpcId::Tag, 0, tag };
c@125:     case piper::RpcRequest::Id::Which::NONE:
c@125:         return { RequestOrResponse::RpcId::Absent, 0, "" };
c@125:     }
cannam@154:     return { RequestOrResponse::RpcId::Absent, 0, "" };
c@125: }
c@125: 
c@125: static void
c@125: buildId(piper::RpcResponse::Builder &b, const RequestOrResponse::RpcId &id)
c@125: {
c@125:     switch (id.type) {
c@125:     case RequestOrResponse::RpcId::Number:
c@125:         b.getId().setNumber(id.number);
c@125:         break;
c@125:     case RequestOrResponse::RpcId::Tag:
c@125:         b.getId().setTag(id.tag);
c@125:         break;
c@125:     case RequestOrResponse::RpcId::Absent:
c@125:         b.getId().setNone();
c@125:         break;
c@125:     }
c@125: }
c@125: 
c@125: static RequestOrResponse::RpcId
c@125: readJsonId(const Json &j)
c@125: {
c@125:     RequestOrResponse::RpcId id;
c@125: 
c@125:     if (j["id"].is_number()) {
c@125:         id.type = RequestOrResponse::RpcId::Number;
c@140:         id.number = int(round(j["id"].number_value()));
c@125:     } else if (j["id"].is_string()) {
c@125:         id.type = RequestOrResponse::RpcId::Tag;
c@125:         id.tag = j["id"].string_value();
c@125:     } else {
c@125:         id.type = RequestOrResponse::RpcId::Absent;
c@125:     }
c@125: 
c@125:     return id;
c@125: }
c@125: 
c@125: static Json
c@125: writeJsonId(const RequestOrResponse::RpcId &id)
c@125: {
c@125:     if (id.type == RequestOrResponse::RpcId::Number) {
c@125:         return id.number;
c@125:     } else if (id.type == RequestOrResponse::RpcId::Tag) {
c@125:         return id.tag;
c@125:     } else {
c@125:         return Json();
c@125:     }
c@125: }
c@125: 
c@125: static Json
c@125: convertRequestJson(string input, string &err)
c@125: {
c@125:     Json j = Json::parse(input, err);
c@125:     if (err != "") {
c@125:         err = "invalid json: " + err;
c@125:         return {};
c@125:     }
c@125:     if (!j.is_object()) {
c@125:         err = "object expected at top level";
c@125:     } else if (!j["method"].is_string()) {
c@125:         err = "string expected for method field";
c@125:     } else if (!j["params"].is_null() && !j["params"].is_object()) {
c@125:         err = "object expected for params field";
c@125:     }
c@125:     return j;
c@125: }
c@125: 
c@125: RequestOrResponse
cannam@158: readRequestJson(string &err, bool &eof)
c@125: {
c@125:     RequestOrResponse rr;
c@125:     rr.direction = RequestOrResponse::Request;
c@125: 
c@125:     string input;
c@125:     if (!getline(cin, input)) {
c@125:         // the EOF case, not actually an error
cannam@158:         eof = true;
c@125:         return rr;
c@125:     }
c@125:     
c@125:     Json j = convertRequestJson(input, err);
c@125:     if (err != "") return {};
c@125: 
c@125:     rr.type = VampJson::getRequestResponseType(j, err);
c@125:     if (err != "") return {};
c@125: 
c@125:     rr.id = readJsonId(j);
c@125: 
c@125:     VampJson::BufferSerialisation serialisation =
c@125:         VampJson::BufferSerialisation::Array;
c@125: 
c@125:     switch (rr.type) {
c@125: 
c@125:     case RRType::List:
c@130:         rr.listRequest = VampJson::toRpcRequest_List(j, err);
c@125:         break;
c@125:     case RRType::Load:
c@125:         rr.loadRequest = VampJson::toRpcRequest_Load(j, err);
c@125:         break;
c@125:     case RRType::Configure:
c@125:         rr.configurationRequest = VampJson::toRpcRequest_Configure(j, mapper, err);
c@125:         break;
c@125:     case RRType::Process:
c@125:         rr.processRequest = VampJson::toRpcRequest_Process(j, mapper, serialisation, err);
c@125:         break;
c@125:     case RRType::Finish:
c@125:         rr.finishRequest = VampJson::toRpcRequest_Finish(j, mapper, err);
c@125:         break;
c@125:     case RRType::NotValid:
c@125:         break;
c@125:     }
c@125: 
c@125:     return rr;
c@125: }
c@125: 
c@125: void
c@125: writeResponseJson(RequestOrResponse &rr, bool useBase64)
c@125: {
c@125:     Json j;
c@125: 
c@125:     VampJson::BufferSerialisation serialisation =
c@125:         (useBase64 ?
c@125:          VampJson::BufferSerialisation::Base64 :
c@125:          VampJson::BufferSerialisation::Array);
c@125: 
c@125:     Json id = writeJsonId(rr.id);
c@125: 
c@125:     if (!rr.success) {
c@125: 
c@125:         j = VampJson::fromError(rr.errorText, rr.type, id);
c@125: 
c@125:     } else {
c@125:     
c@125:         switch (rr.type) {
c@125: 
c@125:         case RRType::List:
c@125:             j = VampJson::fromRpcResponse_List(rr.listResponse, id);
c@125:             break;
c@125:         case RRType::Load:
c@125:             j = VampJson::fromRpcResponse_Load(rr.loadResponse, mapper, id);
c@125:             break;
c@125:         case RRType::Configure:
c@125:             j = VampJson::fromRpcResponse_Configure(rr.configurationResponse,
c@125:                                                     mapper, id);
c@125:             break;
c@125:         case RRType::Process:
c@125:             j = VampJson::fromRpcResponse_Process
c@125:                 (rr.processResponse, mapper, serialisation, id);
c@125:             break;
c@125:         case RRType::Finish:
c@125:             j = VampJson::fromRpcResponse_Finish
c@125:                 (rr.finishResponse, mapper, serialisation, id);
c@125:             break;
c@125:         case RRType::NotValid:
c@125:             break;
c@125:         }
c@125:     }
c@138: 
c@125:     cout << j.dump() << endl;
c@125: }
c@125: 
c@125: void
cannam@158: writeExceptionJson(const exception &e, RRType type, RequestOrResponse::RpcId id)
c@125: {
cannam@158:     Json jid = writeJsonId(id);
cannam@158:     Json j = VampJson::fromError(e.what(), type, jid);
c@125:     cout << j.dump() << endl;
c@125: }
c@125: 
c@125: RequestOrResponse
cannam@158: readRequestCapnp(bool &eof)
c@125: {
c@125:     RequestOrResponse rr;
c@125:     rr.direction = RequestOrResponse::Request;
c@125: 
c@125:     static kj::FdInputStream stream(0); // stdin
c@125:     static kj::BufferedInputStreamWrapper buffered(stream);
c@125: 
c@125:     if (buffered.tryGetReadBuffer() == nullptr) {
cannam@158:         eof = true;
c@125:         return rr;
c@125:     }
c@125: 
c@125:     capnp::InputStreamMessageReader message(buffered);
c@125:     piper::RpcRequest::Reader reader = message.getRoot<piper::RpcRequest>();
c@125:     
c@125:     rr.type = VampnProto::getRequestResponseType(reader);
c@125:     rr.id = readId(reader);
c@125: 
c@125:     switch (rr.type) {
c@125: 
c@125:     case RRType::List:
c@127:         VampnProto::readRpcRequest_List(rr.listRequest, reader);
c@125:         break;
c@125:     case RRType::Load:
c@125:         VampnProto::readRpcRequest_Load(rr.loadRequest, reader);
c@125:         break;
c@125:     case RRType::Configure:
c@125:         VampnProto::readRpcRequest_Configure(rr.configurationRequest,
c@125:                                              reader, mapper);
c@125:         break;
c@125:     case RRType::Process:
c@125:         VampnProto::readRpcRequest_Process(rr.processRequest, reader, mapper);
c@125:         break;
c@125:     case RRType::Finish:
c@125:         VampnProto::readRpcRequest_Finish(rr.finishRequest, reader, mapper);
c@125:         break;
c@125:     case RRType::NotValid:
c@125:         break;
c@125:     }
c@125: 
c@125:     return rr;
c@125: }
c@125: 
c@125: void
c@125: writeResponseCapnp(RequestOrResponse &rr)
c@125: {
c@125:     capnp::MallocMessageBuilder message;
c@125:     piper::RpcResponse::Builder builder = message.initRoot<piper::RpcResponse>();
c@125: 
c@125:     buildId(builder, rr.id);
c@125:     
c@125:     if (!rr.success) {
c@125: 
c@125:         VampnProto::buildRpcResponse_Error(builder, rr.errorText, rr.type);
c@125: 
c@125:     } else {
c@125:         
c@125:         switch (rr.type) {
c@125: 
c@125:         case RRType::List:
c@125:             VampnProto::buildRpcResponse_List(builder, rr.listResponse);
c@125:             break;
c@125:         case RRType::Load:
c@125:             VampnProto::buildRpcResponse_Load(builder, rr.loadResponse, mapper);
c@125:             break;
c@125:         case RRType::Configure:
c@125:             VampnProto::buildRpcResponse_Configure(builder, rr.configurationResponse, mapper);
c@125:             break;
c@125:         case RRType::Process:
c@125:             VampnProto::buildRpcResponse_Process(builder, rr.processResponse, mapper);
c@125:             break;
c@125:         case RRType::Finish:
c@125:             VampnProto::buildRpcResponse_Finish(builder, rr.finishResponse, mapper);
c@125:             break;
c@125:         case RRType::NotValid:
c@125:             break;
c@125:         }
c@125:     }
c@125:     
c@125:     writeMessageToFd(1, message);
c@125: }
c@125: 
c@125: void
cannam@158: writeExceptionCapnp(const exception &e, RRType type, RequestOrResponse::RpcId id)
c@125: {
c@125:     capnp::MallocMessageBuilder message;
c@125:     piper::RpcResponse::Builder builder = message.initRoot<piper::RpcResponse>();
cannam@158: 
cannam@158:     buildId(builder, id);
c@125:     VampnProto::buildRpcResponse_Exception(builder, e, type);
c@125:     
c@125:     writeMessageToFd(1, message);
c@125: }
c@125: 
c@125: RequestOrResponse
c@125: handleRequest(const RequestOrResponse &request, bool debug)
c@125: {
c@125:     RequestOrResponse response;
c@125:     response.direction = RequestOrResponse::Response;
c@125:     response.type = request.type;
c@125: 
c@125:     switch (request.type) {
c@125: 
c@125:     case RRType::List:
c@127:         response.listResponse =
c@127:             LoaderRequests().listPluginData(request.listRequest);
c@125:         response.success = true;
c@125:         break;
c@125: 
c@125:     case RRType::Load:
c@127:         response.loadResponse =
c@127:             LoaderRequests().loadPlugin(request.loadRequest);
cannam@293: 
cannam@293:         if (!response.loadResponse.plugin) {
cannam@293:             throw runtime_error("unable to load plugin");
c@125:         }
cannam@293:             
cannam@293:         mapper.addPlugin(response.loadResponse.plugin);
cannam@293:         if (debug) {
cannam@293:             cerr << "piper-vamp-server " << pid
cannam@293:                  << ": loaded plugin, handle = "
cannam@293:                  << mapper.pluginToHandle(response.loadResponse.plugin)
cannam@293:                  << endl;
cannam@293:         }
cannam@293:         response.success = true;
c@125:         break;
c@125:         
c@125:     case RRType::Configure:
c@125:     {
c@125:         auto &creq = request.configurationRequest;
cannam@158:         if (!creq.plugin) {
cannam@158:             throw runtime_error("unknown plugin handle supplied to configure");
cannam@158:         }
cannam@158:             
c@125:         auto h = mapper.pluginToHandle(creq.plugin);
c@125:         if (mapper.isConfigured(h)) {
c@125:             throw runtime_error("plugin has already been configured");
c@125:         }
c@125: 
cannam@185:         if (creq.configuration.framing.stepSize == 0 ||
cannam@185:             creq.configuration.framing.blockSize == 0) {
cannam@185:             throw runtime_error("step and block size must be non-zero");
cannam@185:         }
cannam@185: 
c@125:         response.configurationResponse = LoaderRequests().configurePlugin(creq);
cannam@293: 
cannam@293:         if (response.configurationResponse.outputs.empty()) {
cannam@293:             throw runtime_error("plugin failed to initialise");
cannam@293:         }
c@125:         
cannam@293:         mapper.markConfigured
cannam@293:             (h,
cannam@293:              creq.configuration.channelCount,
cannam@293:              response.configurationResponse.framing.blockSize);
cannam@293:         response.success = true;
c@125:         break;
c@125:     }
c@125: 
c@125:     case RRType::Process:
c@125:     {
c@125:         auto &preq = request.processRequest;
cannam@158:         if (!preq.plugin) {
cannam@158:             throw runtime_error("unknown plugin handle supplied to process");
cannam@158:         }
cannam@158: 
c@125:         auto h = mapper.pluginToHandle(preq.plugin);
c@125:         if (!mapper.isConfigured(h)) {
c@125:             throw runtime_error("plugin has not been configured");
c@125:         }
c@125: 
c@125:         int channels = int(preq.inputBuffers.size());
c@125:         if (channels != mapper.getChannelCount(h)) {
c@125:             throw runtime_error("wrong number of channels supplied to process");
c@125:         }
c@125:                 
c@125:         const float **fbuffers = new const float *[channels];
cannam@271: 
cannam@271:         bool frequencyDomain =
cannam@271:             (preq.plugin->getInputDomain() == Vamp::Plugin::FrequencyDomain);
cannam@271:         int blockSize = mapper.getBlockSize(h);
cannam@271:         int inputBufferSize;
cannam@271:         if (frequencyDomain) {
cannam@271:             inputBufferSize = 2 * (blockSize / 2) + 2;
cannam@271:         } else {
cannam@271:             inputBufferSize = blockSize;
cannam@271:         }
cannam@271:         
c@125:         for (int i = 0; i < channels; ++i) {
cannam@271:             if (int(preq.inputBuffers[i].size()) != inputBufferSize) {
cannam@186:                 ostringstream os;
cannam@271:                 os << "wrong buffer size passed to process call as "
cannam@271:                    << (frequencyDomain ? "frequency" : "time")
cannam@271:                    << "-domain input on channel " << i << " with block size "
cannam@271:                    << blockSize << " (expected " << inputBufferSize
cannam@271:                    << " values, obtained " << preq.inputBuffers[i].size()
cannam@271:                    << ")" << ends;
c@125:                 delete[] fbuffers;
cannam@186:                 throw runtime_error(os.str());
c@125:             }
c@125:             fbuffers[i] = preq.inputBuffers[i].data();
c@125:         }
c@125: 
c@125:         response.processResponse.plugin = preq.plugin;
c@125:         response.processResponse.features =
c@125:             preq.plugin->process(fbuffers, preq.timestamp);
c@125:         response.success = true;
c@125: 
c@125:         delete[] fbuffers;
c@125:         break;
c@125:     }
c@125: 
c@125:     case RRType::Finish:
c@125:     {
c@125:         auto &freq = request.finishRequest;
cannam@158:         if (!freq.plugin) {
cannam@158:             throw runtime_error("unknown plugin handle supplied to finish");
cannam@158:         }
cannam@158: 
c@125:         response.finishResponse.plugin = freq.plugin;
c@125: 
c@125:         auto h = mapper.pluginToHandle(freq.plugin);
c@125:         // Finish can be called (to unload the plugin) even if the
c@125:         // plugin has never been configured or used. But we want to
c@125:         // make sure we call getRemainingFeatures only if we have
c@125:         // actually configured the plugin.
c@125:         if (mapper.isConfigured(h)) {
c@125:             response.finishResponse.features = freq.plugin->getRemainingFeatures();
c@125:         }
c@125: 
c@125:         // We do not delete the plugin here -- we need it in the
c@125:         // mapper when converting the features. It gets deleted in the
c@125:         // calling function.
c@125:         response.success = true;
c@125:         break;
c@125:     }
c@125: 
c@125:     case RRType::NotValid:
c@125:         break;
c@125:     }
c@125:     
c@125:     return response;
c@125: }
c@125: 
c@125: RequestOrResponse
cannam@158: readRequest(string format, bool &eof)
c@125: {
c@125:     if (format == "capnp") {
cannam@158:         return readRequestCapnp(eof);
c@125:     } else if (format == "json") {
c@125:         string err;
cannam@158:         auto result = readRequestJson(err, eof);
c@125:         if (err != "") throw runtime_error(err);
c@125:         else return result;
c@125:     } else {
c@125:         throw runtime_error("unknown input format \"" + format + "\"");
c@125:     }
c@125: }
c@125: 
c@125: void
c@125: writeResponse(string format, RequestOrResponse &rr)
c@125: {
c@138:     resumeOutput();
c@125:     if (format == "capnp") {
c@125:         writeResponseCapnp(rr);
c@125:     } else if (format == "json") {
c@125:         writeResponseJson(rr, false);
c@125:     } else {
c@125:         throw runtime_error("unknown output format \"" + format + "\"");
c@125:     }
c@138:     suspendOutput();
c@125: }
c@125: 
c@125: void
cannam@158: writeException(string format, const exception &e, RRType type, RequestOrResponse::RpcId id)
c@125: {
c@138:     resumeOutput();
c@125:     if (format == "capnp") {
cannam@158:         writeExceptionCapnp(e, type, id);
c@125:     } else if (format == "json") {
cannam@158:         writeExceptionJson(e, type, id);
c@125:     } else {
c@125:         throw runtime_error("unknown output format \"" + format + "\"");
c@125:     }
c@138:     suspendOutput();
c@125: }
c@125: 
c@125: int main(int argc, char **argv)
c@125: {
c@125:     if (argc != 2 && argc != 3) {
c@125:         usage();
c@125:     }
c@125: 
c@125:     bool debug = false;
c@125:     
c@125:     string arg = argv[1];
cannam@279:     if (arg == "-h" || arg == "--help") {
c@125:         if (argc == 2) {
c@125:             usage(true);
c@125:         } else {
c@125:             usage();
c@125:         }
cannam@279:     } else if (arg == "-v" || arg == "--version") {
c@125:         if (argc == 2) {
c@125:             version();
c@125:         } else {
c@125:             usage();
c@125:         }
cannam@279:     } else if (arg == "-d" || arg == "--debug") {
c@125:         if (argc == 2) {
c@125:             usage();
c@125:         } else {
c@125:             debug = true;
c@125:             arg = argv[2];
c@125:         }
c@125:     }
c@125:     
c@125:     string format = arg;
c@125: 
c@125:     if (format != "capnp" && format != "json") {
c@125:         usage();
c@125:     }
c@125: 
c@138:     try {            
c@138:         initFds(format == "capnp");
c@138:     } catch (exception &e) {
c@138:         cerr << "ERROR: " << e.what() << endl;
c@138:         exit(1);
c@125:     }
c@138: 
c@138:     suspendOutput();
c@125: 
c@125:     if (debug) {
c@125:         cerr << myname << " " << pid << ": waiting for format: " << format << endl;
cannam@228:         if (format == "json") {
cannam@281:             cerr << myname << " " << pid << ": to test the server, try {\"method\": \"list\"}" << endl;
cannam@228:         }
c@125:     }
c@138:     
c@125:     while (true) {
c@125: 
c@125:         RequestOrResponse request;
c@125:         
c@125:         try {
c@125: 
cannam@158:             bool eof = false;
cannam@158:             request = readRequest(format, eof);
c@125:             
cannam@158:             if (eof) {
c@125:                 if (debug) {
c@125:                     cerr << myname << " " << pid << ": eof reached, exiting" << endl;
c@125:                 }
c@125:                 break;
c@125:             }
c@125: 
c@125:             if (debug) {
c@125:                 cerr << myname << " " << pid << ": request received, of type "
c@125:                      << int(request.type)
c@125:                      << endl;
c@125:             }
cannam@158:             
cannam@158:         } catch (exception &e) {
c@125: 
cannam@158:             if (debug) {
cannam@158:                 cerr << myname << " " << pid << ": error: " << e.what() << endl;
cannam@158:             }
cannam@158: 
cannam@158:             writeException(format, e, request.type, request.id);
cannam@158: 
cannam@158:             if (format == "capnp") {
cannam@158:                 // Don't try to continue; we can't recover from a
cannam@158:                 // mangled input stream. However, we can return a
cannam@158:                 // successful error code because we are reporting the
cannam@158:                 // status in our Capnp output stream instead
cannam@158:                 if (debug) {
cannam@158:                     cerr << myname << " " << pid << ": not attempting to recover from capnp parse problems, exiting" << endl;
cannam@158:                 }
cannam@158:                 exit(0);
cannam@158:             }
cannam@158:         }
cannam@158: 
cannam@158:         try {
c@125:             RequestOrResponse response = handleRequest(request, debug);
c@125:             response.id = request.id;
c@125: 
c@125:             if (debug) {
c@125:                 cerr << myname << " " << pid << ": request handled, writing response"
c@125:                      << endl;
c@125:             }
c@125:             
c@125:             writeResponse(format, response);
c@125: 
c@125:             if (debug) {
c@125:                 cerr << myname << " " << pid << ": response written" << endl;
c@125:             }
c@125: 
c@125:             if (request.type == RRType::Finish) {
c@125:                 auto h = mapper.pluginToHandle(request.finishRequest.plugin);
c@125:                 if (debug) {
c@125:                     cerr << myname << " " << pid << ": deleting the plugin with handle " << h << endl;
c@125:                 }
c@125:                 mapper.removePlugin(h);
c@125:                 delete request.finishRequest.plugin;
c@125:             }
c@125:             
c@138:         } catch (exception &e) {
c@125: 
c@125:             if (debug) {
c@125:                 cerr << myname << " " << pid << ": error: " << e.what() << endl;
c@125:             }
c@125: 
cannam@158:             writeException(format, e, request.type, request.id);
c@125:         }
c@125:     }
c@125: 
c@125:     exit(0);
c@125: }