VuoRunner.hh

Go to the documentation of this file.

 
#pragma once
 
#include <map>
#include <set>
 
#include "VuoMacOSSDKWorkaround.h"
#include <dispatch/dispatch.h>
#include "VuoTelemetry.hh"
class VuoRunnerDelegate;
class VuoRunningCompositionLibraries;
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdocumentation"
#include "json-c/json.h"
#pragma clang diagnostic pop
 
 
class VuoRunner
{
public:
    class Port;
    static VuoRunner * newSeparateProcessRunnerFromExecutable(string executablePath, string sourceDir, bool continueIfRunnerDies, bool deleteExecutableWhenFinished);
    static VuoRunner * newSeparateProcessRunnerFromDynamicLibrary(string compositionLoaderPath, string compositionDylibPath, const std::shared_ptr<VuoRunningCompositionLibraries> &runningCompositionLibraries, string sourceDir, bool continueIfRunnerDies = false, bool deleteDylibsWhenFinished = false);
    static VuoRunner * newCurrentProcessRunnerFromDynamicLibrary(string dylibPath, string sourceDir, bool deleteDylibWhenFinished = false);
    ~VuoRunner(void);
    void setRuntimeChecking(bool runtimeCheckingEnabled);
    void start(void);
    void startPaused(void);
    void runOnMainThread(void);
    void drainMainDispatchQueue(void);
    void pause(void);
    void unpause(void);
    void replaceComposition(string compositionDylibPath, string compositionDiff);
    void stop(void);
    void waitUntilStopped(void);
    void setPublishedInputPortValues(map<Port *, json_object *> portsAndValues);
    void firePublishedInputPortEvent(Port *port);
    void firePublishedInputPortEvent(const set<Port *> &ports);
    void waitForFiredPublishedInputPortEvent(void);
    json_object * getPublishedInputPortValue(Port *port);
    json_object * getPublishedOutputPortValue(Port *port);
    vector<Port *> getPublishedInputPorts(void);
    vector<Port *> getPublishedOutputPorts(void);
    Port * getPublishedInputPortWithName(string name);
    Port * getPublishedOutputPortWithName(string name);
    void setInputPortValue(string compositionIdentifier, string portIdentifier, json_object *value);
    void fireTriggerPortEvent(string compositionIdentifier, string portIdentifier);
    json_object * getInputPortValue(string compositionIdentifier, string portIdentifier);
    json_object * getOutputPortValue(string compositionIdentifier, string portIdentifier);
    string getInputPortSummary(string compositionIdentifier, string portIdentifier);
    string getOutputPortSummary(string compositionIdentifier, string portIdentifier);
    string subscribeToInputPortTelemetry(string compositionIdentifier, string portIdentifier);
    string subscribeToOutputPortTelemetry(string compositionIdentifier, string portIdentifier);
    void unsubscribeFromInputPortTelemetry(string compositionIdentifier, string portIdentifier);
    void unsubscribeFromOutputPortTelemetry(string compositionIdentifier, string portIdentifier);
    void subscribeToEventTelemetry(string compositionIdentifier);
    void unsubscribeFromEventTelemetry(string compositionIdentifier);
    void subscribeToAllTelemetry(string compositionIdentifier);
    void unsubscribeFromAllTelemetry(string compositionIdentifier);
    bool isStopped(void);
    void setDelegate(VuoRunnerDelegate *delegate);
    pid_t getCompositionPid();
 
    class Port
    {
    public:
        Port(string name, string type, json_object *details);
        string getName(void);
        string getType(void);
        json_object *getDetails(void);
 
        friend class VuoRunner;
 
    private:
        string name;
        string type;
        json_object *details;
    };
 
private:
    string executablePath;  
    string dylibPath;  
    void *dylibHandle;  
    std::shared_ptr<VuoRunningCompositionLibraries> dependencyLibraries;  
    bool shouldContinueIfRunnerDies;  
    bool shouldDeleteBinariesWhenFinished;  
    string sourceDir;  
    bool isRuntimeCheckingEnabled;
    bool paused;  
    bool stopped;   
    bool lostContact;   
    string listenError;   
    bool listenCanceled;  
    dispatch_semaphore_t stoppedSemaphore;  
    dispatch_semaphore_t terminatedZMQContextSemaphore;  
    dispatch_semaphore_t beganListeningSemaphore;  
    dispatch_semaphore_t endedListeningSemaphore;  
    dispatch_semaphore_t lastFiredEventSemaphore;  
    bool lastFiredEventSignaled;  
    dispatch_queue_t controlQueue;  
    pid_t compositionPid;   
    int runnerReadCompositionWritePipe[2];  
 
    void *ZMQContext;   
    void *ZMQSelfReceive;   
    void *ZMQSelfSend;      
    void *ZMQControl;   
    void *ZMQTelemetry; 
    void *ZMQLoaderControl;  
    string ZMQControlURL;  
    string ZMQLoaderControlURL;  
    string ZMQTelemetryURL;  
 
    VuoRunnerDelegate *delegate;  
    dispatch_queue_t delegateQueue;  
 
    vector<Port *> publishedInputPorts;
    vector<Port *> publishedOutputPorts;
    bool arePublishedInputPortsCached;  
    bool arePublishedOutputPortsCached; 
 
    class Private;
    Private *p;
 
    void saturating_semaphore_signal(dispatch_semaphore_t dsema, bool *sent);
    void saturating_semaphore_wait(dispatch_semaphore_t dsema, bool *sent);
 
    VuoRunner(void);
    void startInternal(void);
    void listen();
    void setUpConnections(void);
    void cleanUpConnections(void);
    void vuoControlRequestSend(enum VuoControlRequest request, zmq_msg_t *messages, unsigned int messageCount);
    void vuoLoaderControlRequestSend(enum VuoLoaderControlRequest request, zmq_msg_t *messages, unsigned int messageCount);
    void vuoControlReplyReceive(enum VuoControlReply expectedReply);
    void vuoLoaderControlReplyReceive(enum VuoLoaderControlReply expectedReply);
    string receiveString(string fallbackIfNull);
    vector<string> receiveListOfStrings(void);
    vector<Port *> getCachedPublishedPorts(bool input);
    vector<Port *> refreshPublishedPorts(bool input);
    bool isInCurrentProcess(void);
    bool isUsingCompositionLoader(void);
    void stopBecauseLostContact(string errorMessage);
    void copyDylibAndChangeId(string dylibPath, string &outputDylibPath);
 
    friend void *VuoRunner_listen(void *context);
    friend class TestControlAndTelemetry;
    friend class TestVuoRunner;
};
 
 
class VuoRunnerDelegate
{
public:
    virtual void receivedTelemetryStats(unsigned long utime, unsigned long stime) = 0;
 
    virtual void receivedTelemetryNodeExecutionStarted(string compositionIdentifier, string nodeIdentifier) = 0;
 
    virtual void receivedTelemetryNodeExecutionFinished(string compositionIdentifier, string nodeIdentifier) = 0;
 
    virtual void receivedTelemetryInputPortUpdated(string compositionIdentifier, string portIdentifier, bool receivedEvent, bool receivedData, string dataSummary) = 0;
 
    virtual void receivedTelemetryOutputPortUpdated(string compositionIdentifier, string portIdentifier, bool sentEvent, bool sentData, string dataSummary) = 0;
 
    virtual void receivedTelemetryPublishedOutputPortUpdated(VuoRunner::Port *port, bool sentData, string dataSummary) = 0;
 
    virtual void receivedTelemetryEventDropped(string compositionIdentifier, string portIdentifier) = 0;
 
    virtual void receivedTelemetryError(string message) = 0;
 
    virtual void lostContactWithComposition(void) = 0;
 
    virtual ~VuoRunnerDelegate() = 0;  // Fixes "virtual functions but non-virtual destructor" warning
};
 
#define VUO_UNUSED_VARIABLE __attribute__((unused))
 
class VuoRunnerDelegateAdapter : public VuoRunnerDelegate
{
private:
    virtual void receivedTelemetryStats(unsigned long VUO_UNUSED_VARIABLE utime, unsigned long VUO_UNUSED_VARIABLE stime) { }
    virtual void receivedTelemetryNodeExecutionStarted(string VUO_UNUSED_VARIABLE compositionIdentifier, string VUO_UNUSED_VARIABLE nodeIdentifier) { }
    virtual void receivedTelemetryNodeExecutionFinished(string VUO_UNUSED_VARIABLE compositionIdentifier, string VUO_UNUSED_VARIABLE nodeIdentifier) { }
    virtual void receivedTelemetryInputPortUpdated(string VUO_UNUSED_VARIABLE compositionIdentifier, string VUO_UNUSED_VARIABLE portIdentifier, bool VUO_UNUSED_VARIABLE receivedEvent, bool VUO_UNUSED_VARIABLE receivedData, string VUO_UNUSED_VARIABLE dataSummary) { }
    virtual void receivedTelemetryOutputPortUpdated(string VUO_UNUSED_VARIABLE compositionIdentifier, string VUO_UNUSED_VARIABLE portIdentifier, bool VUO_UNUSED_VARIABLE sentEvent, bool VUO_UNUSED_VARIABLE sentData, string VUO_UNUSED_VARIABLE dataSummary) { }
    virtual void receivedTelemetryPublishedOutputPortUpdated(VuoRunner::Port VUO_UNUSED_VARIABLE *port, bool VUO_UNUSED_VARIABLE sentData, string VUO_UNUSED_VARIABLE dataSummary) { }
    virtual void receivedTelemetryEventDropped(string VUO_UNUSED_VARIABLE compositionIdentifier, string VUO_UNUSED_VARIABLE portIdentifier) { }
    virtual void receivedTelemetryError(string VUO_UNUSED_VARIABLE message) { }
    virtual void lostContactWithComposition(void) { }
};