comparison vamp-client/CapnpRRClient.h @ 134:3dcf0394971d

Debug output improvements, and make the checker actually attempt to call the descriptor function for known plugin types

 #include "PluginStub.h"
 #include "SynchronousTransport.h"
 
 #include "vamp-support/AssignedPluginHandleMapper.h"
 #include "vamp-capnp/VampnProto.h"
+
+#include <sstream>
 
 #include <capnp/serialize.h>
 
 namespace piper_vamp {
 namespace client {

             return words >= expected;
         }
     };
     
 public:
-    CapnpRRClient(SynchronousTransport *transport) : //!!! ownership? shared ptr?
+    CapnpRRClient(SynchronousTransport *transport, //!!! ownership? shared ptr?
+                  LogCallback *logger) : // logger may be nullptr for cerr
+        m_logger(logger),
         m_transport(transport),
         m_completenessChecker(new CompletenessChecker) {
         transport->setCompletenessChecker(m_completenessChecker);
     }
 

 
     ListResponse
     listPluginData(const ListRequest &req) override {
 
         if (!m_transport->isOK()) {
+            log("Piper server crashed or failed to start (caller should have checked this)");
             throw std::runtime_error("Piper server crashed or failed to start");
         }
 
         capnp::MallocMessageBuilder message;
         piper::RpcRequest::Builder builder = message.initRoot<piper::RpcRequest>();
         VampnProto::buildRpcRequest_List(builder, req);
         ReqId id = getId();
         builder.getId().setNumber(id);
 
-        auto karr = call(message, true);
+        auto karr = call(message, "list", true);
 
         capnp::FlatArrayMessageReader responseMessage(karr);
         piper::RpcResponse::Reader reader = responseMessage.getRoot<piper::RpcResponse>();
 
         checkResponseType(reader, piper::RpcResponse::Response::Which::LIST, id);

     
     LoadResponse
     loadPlugin(const LoadRequest &req) override {
 
         if (!m_transport->isOK()) {
+            log("Piper server crashed or failed to start (caller should have checked this)");
             throw std::runtime_error("Piper server crashed or failed to start");
         }
 
         LoadResponse resp;
         PluginHandleMapper::Handle handle = serverLoad(req.pluginKey,

     Vamp::Plugin::OutputList
     configure(PluginStub *plugin,
               PluginConfiguration config) override {
 
         if (!m_transport->isOK()) {
+            log("Piper server crashed or failed to start (caller should have checked this)");
             throw std::runtime_error("Piper server crashed or failed to start");
         }
 
         ConfigurationRequest request;
         request.plugin = plugin;

 
         VampnProto::buildRpcRequest_Configure(builder, request, m_mapper);
         ReqId id = getId();
         builder.getId().setNumber(id);
 
-        auto karr = call(message, true);
+        auto karr = call(message, "configure", true);
 
         capnp::FlatArrayMessageReader responseMessage(karr);
         piper::RpcResponse::Reader reader = responseMessage.getRoot<piper::RpcResponse>();
 
         //!!! handle (explicit) error case

     process(PluginStub *plugin,
             std::vector<std::vector<float> > inputBuffers,
             Vamp::RealTime timestamp) override {
 
         if (!m_transport->isOK()) {
+            log("Piper server crashed or failed to start (caller should have checked this)");
             throw std::runtime_error("Piper server crashed or failed to start");
         }
 
         ProcessRequest request;
         request.plugin = plugin;

         piper::RpcRequest::Builder builder = message.initRoot<piper::RpcRequest>();
         VampnProto::buildRpcRequest_Process(builder, request, m_mapper);
         ReqId id = getId();
         builder.getId().setNumber(id);
 
-        auto karr = call(message, false);
+        auto karr = call(message, "process", false);
 
         capnp::FlatArrayMessageReader responseMessage(karr);
         piper::RpcResponse::Reader reader = responseMessage.getRoot<piper::RpcResponse>();
 
         //!!! handle (explicit) error case

 
     virtual Vamp::Plugin::FeatureSet
     finish(PluginStub *plugin) override {
 
         if (!m_transport->isOK()) {
+            log("Piper server crashed or failed to start (caller should have checked this)");
             throw std::runtime_error("Piper server crashed or failed to start");
         }
 
         FinishRequest request;
         request.plugin = plugin;

 
         VampnProto::buildRpcRequest_Finish(builder, request, m_mapper);
         ReqId id = getId();
         builder.getId().setNumber(id);
         
-        auto karr = call(message, true);
+        auto karr = call(message, "finish", true);
 
         capnp::FlatArrayMessageReader responseMessage(karr);
         piper::RpcResponse::Reader reader = responseMessage.getRoot<piper::RpcResponse>();
 
         //!!! handle (explicit) error case

     virtual void
     reset(PluginStub *plugin,
           PluginConfiguration config) override {
 
         // Reload the plugin on the server side, and configure it as requested
-        
-        if (!m_transport->isOK()) {
+
+        log("CapnpRRClient: reset() called, plugin will be closed and reloaded");
+        
+        if (!m_transport->isOK()) {
+            log("Piper server crashed or failed to start (caller should have checked this)");
             throw std::runtime_error("Piper server crashed or failed to start");
         }
 
         if (m_mapper.havePlugin(plugin)) {
             (void)finish(plugin); // server-side unload

     checkResponseType(const piper::RpcResponse::Reader &r,
                       piper::RpcResponse::Response::Which type,
                       ReqId id) {
         
         if (r.getResponse().which() != type) {
-            std::cerr << "checkResponseType: wrong response type (received "
-                      << int(r.getResponse().which()) << ", expected "
-                      << int(type) << ")"
-                      << std::endl;
+            std::ostringstream s;
+            s << "checkResponseType: wrong response type (received "
+              << int(r.getResponse().which()) << ", expected " << int(type) << ")";
+            log(s.str());
             throw std::runtime_error("Wrong response type");
         }
         if (ReqId(r.getId().getNumber()) != id) {
-            std::cerr << "checkResponseType: wrong response id (received "
-                      << r.getId().getNumber() << ", expected " << id << ")"
-                      << std::endl;
+            std::ostringstream s;
+            s << "checkResponseType: wrong response id (received "
+              << r.getId().getNumber() << ", expected " << id << ")";
+            log(s.str());
             throw std::runtime_error("Wrong response id");
         }
     }
 
     kj::Array<capnp::word>
-    call(capnp::MallocMessageBuilder &message, bool slow) {
+    call(capnp::MallocMessageBuilder &message, std::string type, bool slow) {
         auto arr = capnp::messageToFlatArray(message);
         auto responseBuffer = m_transport->call(arr.asChars().begin(),
                                                 arr.asChars().size(),
+                                                type,
                                                 slow);
         return toKJArray(responseBuffer);
     }
     
     PluginHandleMapper::Handle

 
         VampnProto::buildRpcRequest_Load(builder, request);
         ReqId id = getId();
         builder.getId().setNumber(id);
 
-        auto karr = call(message, false);
+        auto karr = call(message, "load", false);
 
         //!!! ... --> will also need some way to kill this process
         //!!! (from another thread)
 
         capnp::FlatArrayMessageReader responseMessage(karr);

         VampnProto::readConfiguration(defaultConfig, lr.getDefaultConfiguration());
         return lr.getHandle();
     };     
 
 private:
+    LogCallback *m_logger;
     SynchronousTransport *m_transport; //!!! I don't own this, but should I?
     CompletenessChecker *m_completenessChecker; // I own this
+    
+    void log(std::string message) const {
+        if (m_logger) m_logger->log(message);
+        else std::cerr << message << std::endl;
+    }
 };
 
 }
 }