vrpc 2.5.0 → 3.0.0-alpha.2

package/third_party/install.sh

@@ -1,22 +0,0 @@
-#!/bin/bash
-
-script_dir=$(dirname `[[ $0 = /* ]] && echo "$0" || echo "$PWD/${0#./}"`)
-cd ${script_dir}
-if [ $? -ne 0 ]; then
-    echo " Could not change directory to ${script_dir}"
-    exit 1;
-fi
-
-INSTALL_PREFIX=${script_dir}
-mkdir -p build
-mkdir -p include
-pushd build
-
-### CATCH (for testing) ###
-
-if [ ! -f ${INSTALL_PREFIX}/include/catch.hpp ]; then
-    wget https://github.com/catchorg/Catch2/releases/download/v2.1.1/catch.hpp
-    cp catch.hpp ../include
-fi
-
-popd

package/vrpc/VrpcLocal.js

@@ -1,264 +0,0 @@
-/*
-__/\\\________/\\\____/\\\\\\\\\______/\\\\\\\\\\\\\_________/\\\\\\\\\_
-__\/\\\_______\/\\\__/\\\///////\\\___\/\\\/////////\\\____/\\\////////__
- __\//\\\______/\\\__\/\\\_____\/\\\___\/\\\_______\/\\\__/\\\/___________
-  ___\//\\\____/\\\___\/\\\\\\\\\\\/____\/\\\\\\\\\\\\\/__/\\\_____________
-   ____\//\\\__/\\\____\/\\\//////\\\____\/\\\/////////___\/\\\_____________
-    _____\//\\\/\\\_____\/\\\____\//\\\___\/\\\____________\//\\\____________
-     ______\//\\\\\______\/\\\_____\//\\\__\/\\\_____________\///\\\__________
-      _______\//\\\_______\/\\\______\//\\\_\/\\\_______________\////\\\\\\\\\_
-       ________\///________\///________\///__\///___________________\/////////__
-
-
-Non-intrusively binds code and provides access in form of asynchronous remote
-procedure calls (RPC).
-Author: Dr. Burkhard C. Heisen (https://github.com/bheisen/vrpc)
-
-
-Licensed under the MIT License <http://opensource.org/licenses/MIT>.
-Copyright (c) 2018 - 2021 Dr. Burkhard C. Heisen <burkhard.heisen@heisenware.com>.
-
-Permission is hereby  granted, free of charge, to any  person obtaining a copy
-of this software and associated  documentation files (the "Software"), to deal
-in the Software  without restriction, including without  limitation the rights
-to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
-copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
-IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
-FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
-AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
-LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-const EventEmitter = require('events')
-const crypto = require('crypto')
-
-/**
- * Client capable of creating proxy objects and locally calling
- * functions as provided through native addons.
- */
-class VrpcLocal {
-  /**
-   * @constructor
-   * @param {Object} adapter An adapter object, typically loaded as native addon
-   */
-  constructor (adapter) {
-    this._eventEmitter = new EventEmitter()
-    this._invokeId = 0
-    this._adapter = adapter
-
-    // Register callback handler
-    this._adapter.onCallback((jsonString, jsonObject) => {
-      // Only JS Adapters will provide the second argument
-      const { id, data } = jsonObject || JSON.parse(jsonString)
-      this._eventEmitter.emit(id, data)
-    })
-  }
-
-  /**
-   * Creates an instance of the specified class.
-   *
-   * @param {String} className Name of the class to create an instance of
-   * @param  {...Any} args Arguments to provide to the constructor
-   * @return {Object} Proxy to the created instance
-   */
-  create (className, ...args) {
-    if (typeof className === 'string') {
-      return this._create({ className, args })
-    }
-    return this._create({
-      className: className.className,
-      instance: className.instance,
-      args: className.args
-    })
-  }
-
-  getInstance ({ className, instance }) {
-    const json = {
-      context: className,
-      method: '__getNamed__',
-      data: { _1: instance }
-    }
-    return this._createProxy(className, json)
-  }
-
-  delete ({ className, instance }) {
-    let context
-    if (typeof (instance) === 'string') {
-      context = instance
-    } else if (typeof (instance) === 'object') {
-      context = instance._targetId
-    }
-    const json = {
-      context: className,
-      method: '__delete__',
-      data: { _1: context }
-    }
-    return JSON.parse(this._adapter.call(JSON.stringify(json))).data.r
-  }
-
-  callStatic (className, functionName, ...args) {
-    const json = {
-      context: className,
-      method: functionName,
-      data: this._packData(className, functionName, ...args)
-    }
-    return JSON.parse(this._adapter.call(JSON.stringify(json))).data.r
-  }
-
-  /**
-   * Retrieves an array of all available classes (names only)
-   *
-   * @return {Array.<String>} Array of class names
-   */
-  getAvailableClasses () {
-    return JSON.parse(this._adapter.getClasses())
-  }
-
-  /**
-   * Provides the names of all currently running instances.
-   *
-   * @param {String} className Name of class to retrieve the instances for
-   * @return {Array.<String>} Array of instance names
-   */
-  getAvailableInstances (className) {
-    return JSON.parse(this._adapter.getInstances(className))
-  }
-
-  /**
-   * Provides all available member functions of the specified class.
-   *
-   * @param {String} className Name of class to provide member functions for
-   * @return {Array.<String>} Array of member function names
-   */
-  getAvailableMemberFunctions (className) {
-    return JSON.parse(this._adapter.getMemberFunctions(className))
-  }
-
-  /**
-   * Provides all available static functions of a registered class.
-   *
-   * @param {String} className Name of class to provide static functions for
-   * @return {Array.<String>} Array of static function names
-   */
-  getAvailableStaticFunctions (className) {
-    return JSON.parse(this._adapter.getStaticFunctions(className))
-  }
-
-  getMetaData (className) {
-    return JSON.parse(this._adapter.getMetaData(className))
-  }
-
-  // private:
-
-  _create ({ className, instance, args = [] }) {
-    const data = instance ? { _1: instance } : {}
-    const offset = instance ? 2 : 1
-    args.forEach((value, index) => {
-      data[`_${index + offset}`] = value
-    })
-    const json = {
-      context: className,
-      method: instance ? '__createNamed__' : '__create__',
-      data
-    }
-    return this._createProxy(className, json)
-  }
-
-  _createProxy (className, json) {
-    // Create instance
-    const ret = JSON.parse(this._adapter.call(JSON.stringify(json)))
-    const instanceId = ret.data.r
-    const proxyId = crypto.randomBytes(2).toString('hex')
-    const proxy = {
-      _targetId: instanceId,
-      _proxyId: proxyId
-    }
-    let functions = JSON.parse(this._adapter.getMemberFunctions(className))
-    // Strip off argument signature
-    functions = functions.map(name => {
-      const pos = name.indexOf('-')
-      if (pos > 0) return name.substring(0, pos)
-      else return name
-    })
-    // Remove overloads
-    const uniqueFuncs = new Set(functions)
-    // Build proxy
-    uniqueFuncs.forEach(name => {
-      proxy[name] = (...args) => {
-        const json = {
-          context: instanceId,
-          method: name,
-          data: this._packData(proxyId, name, ...args)
-        }
-        const { data } = JSON.parse(this._adapter.call(JSON.stringify(json)))
-        if (data.e) throw new Error(data.e)
-        // Handle functions returning a promise
-        if (typeof data.r === 'string' && data.r.substr(0, 5) === '__p__') {
-          return new Promise((resolve, reject) => {
-            this._eventEmitter.once(data.r, promiseData => {
-              if (promiseData.e) reject(new Error(promiseData.e))
-              else resolve(promiseData.r)
-            })
-          })
-        }
-        return data.r
-      }
-    })
-    return proxy
-  }
-
-  _packData (proxyId, functionName, ...args) {
-    const data = {}
-    args.forEach((value, index) => {
-      // Check whether provided argument is a function
-      if (this._isFunction(value)) {
-        const id = `__f__${proxyId}-${functionName}-${index}-${this._invokeId++ % Number.MAX_SAFE_INTEGER}`
-        data[`_${index + 1}`] = id
-        this._eventEmitter.once(id, data => {
-          const args = Object.keys(data).sort()
-            .filter(value => value[0] === '_')
-            .map(key => data[key])
-          value.apply(null, args) // This is the actual function call
-        })
-      } else if (this._isEmitter(value)) {
-        const { emitter, event } = value
-        const id = `__f__${proxyId}-${functionName}-${index}-${event}`
-        data[`_${index + 1}`] = id
-        this._eventEmitter.on(id, data => {
-          const args = Object.keys(data).sort()
-            .filter(value => value[0] === '_')
-            .map(key => data[key])
-          emitter.emit(event, ...args)
-        })
-      } else {
-        data[`_${index + 1}`] = value
-      }
-    })
-    return data
-  }
-
-  _isFunction (variable) {
-    const getType = {}
-    return variable && getType.toString.call(variable) === '[object Function]'
-  }
-
-  _isEmitter (variable) {
-    return (
-      typeof variable === 'object' &&
-      variable.hasOwnProperty('emitter') &&
-      variable.hasOwnProperty('event') &&
-      typeof variable.emitter === 'object' &&
-      typeof variable.emitter.emit === 'function'
-    )
-  }
-}
-
-module.exports = VrpcLocal

package/vrpc/VrpcLocal.py

@@ -1,171 +0,0 @@
-import json
-import sys
-
-
-class Proxy(object):
-
-    def __init__(self, vrpc, caller):
-        self._vrpc = vrpc
-        self._caller = caller
-
-    def _packData(self, function, *args):
-        data = {}
-        for index, arg in enumerate(args):
-            # Argument is function
-            if (hasattr(arg, '__call__')):
-                id = self._caller.register_callback(function, index, arg)
-                data["_{}".format(index + 1)] = id
-            elif (self._isEmitter(arg)):
-                id = self._caller.register_emitter(function, index, arg)
-                data["_{}".format(index + 1)] = id
-            else:
-                data["_{}".format(index + 1)] = arg
-        return data
-
-    def _isEmitter(self, arg):
-        pass
-        return (
-            type(arg) == tuple and
-            len(arg) == 2 and
-            hasattr(arg[0], '__call__') and
-            type(arg[1] == str)
-        )
-
-
-class Caller(object):
-
-    def __init__(self, vrpc):
-        self._invoke_id = 0
-        self._callbacks = {}
-        self._emitters = {}
-        self._vrpc = vrpc
-        self._vrpc.onCallback(self._handle_callback)
-
-    def _handle_callback(self, json_string):
-        payload = json.loads(json_string)
-        id = payload['id']
-        if id in self._callbacks:
-            args = tuple(v for _, v in sorted(payload['data'].items()))
-            self._callbacks[id](*args)
-            self._callbacks.pop(id, None)
-        elif id in self._emitters:
-            emitter = self._emitters[id]
-            args = tuple(v for _, v in sorted(payload['data'].items()))
-            emitter[0](emitter[1], *args)
-
-    def register_callback(self, function, index, callback):
-        id = "__f__{}-{}-{}".format(function, index, self._invoke_id)
-        self._invoke_id = (self._invoke_id + 1) % sys.maxsize
-        if id in self._callbacks:
-            return -1
-        self._callbacks[id] = callback
-        return id
-
-    def register_emitter(self, function, index, emitter):
-        id = "__f__{}-{}".format(function, index)
-        self._emitters[id] = emitter
-        return id
-
-
-class VrpcLocal(object):
-    """Client capable of calling functions as provided by native modules."""
-
-    def __init__(self, module=None):
-        """Constructs an instance of a local client.
-
-        Args:
-            module (obj): A module object, typically loaded as native addon
-
-        Todo:
-            * Existing code reflects only an initial, minimal implementation
-            * Still missing: availability functions, deletion, meta data, etc.
-            * More sophisticated handling of potential threading in loaded addon
-        """
-        self._vrpc = module
-        self._caller = Caller(self._vrpc)
-
-    def create(self, class_name, *args):
-        """Creates an instance of the specified class.
-
-        Args:
-            class_name (str): Name of the class to create an instance of
-            *args Variable number of arguments to provide to the constructor
-
-        Returns:
-            Proxy to the created instance
-        """
-        json_string = {
-            'context': class_name,
-            'method': '__create__',
-            'data': {}
-        }
-        data = json_string['data']
-        for index, a in enumerate(args):
-            data["_{}".format(index + 1)] = a
-
-        # Create instance
-        ret = json.loads(self._vrpc.callRemote(json.dumps(json_string)))
-        instanceId = ret['data']['r']
-        functions = json.loads(
-            self._vrpc.getMemberFunctions(class_name)
-        )['functions']
-        functions = self._remove_overloads(functions)
-        proxy = {
-            # Python lambdas are broken, I can't simply make this a multi-line
-            # statement. Sorry PEP8!
-            '__init__': lambda self, vrpc, caller: Proxy.__init__(self, vrpc, caller)
-        }
-        for function in functions:
-            proxy[function] = self._make_function(instanceId, function, *args)
-        instance = type(class_name, (Proxy,), proxy)(self._vrpc, self._caller)
-        return instance
-
-    def call_static(self, class_name, function_name, *args):
-        """Calls a static function as made available through the native addon.
-
-        Args:
-            class_name (str): Name of the static function's class
-            function_name (str): Name of the static function to be called
-            *args: Positional arguments of the static function call
-
-        Returns:
-            any: The return value of the via-proxy called function
-
-        Todo:
-            * Support callbacks
-        """
-        json_string = {
-            'context': class_name,
-            'method': function_name,
-            'data': {}
-        }
-        data = json_string['data']
-        for index, a in enumerate(args):
-            data["_{}".format(index + 1)] = a
-        ret = json.loads(self._vrpc.callRemote(json.dumps(json_string)))
-        if (ret['data'].get('e')):
-            raise RuntimeError(ret['data']['e'])
-        return ret['data']['r']
-
-    def _remove_overloads(self, functions):
-        uniqueFunctions = set()
-        for function in functions:
-            # Strip off overload signature
-            index = function.find('-')
-            if (index > 0):
-                function = function[0:index]
-            uniqueFunctions.add(function)
-        return uniqueFunctions
-
-    def _make_function(self, instance_id, function, *args):
-        def f(self, *args):
-            json_string = {
-                'context': instance_id,
-                'method': function,
-                'data': self._packData(function, *args)
-            }
-            ret = json.loads(self._vrpc.callRemote(json.dumps(json_string)))
-            if (ret['data'].get('e')):
-                raise RuntimeError(ret['data']['e'])
-            return ret['data']['r']
-        return f

package/vrpc/__init__.py

@@ -1 +0,0 @@
-from .VrpcLocal import VrpcLocal

package/vrpc/module.cpp

@@ -1,183 +0,0 @@
-/*
-__/\\\________/\\\____/\\\\\\\\\______/\\\\\\\\\\\\\_________/\\\\\\\\\_
-__\/\\\_______\/\\\__/\\\///////\\\___\/\\\/////////\\\____/\\\////////__
- __\//\\\______/\\\__\/\\\_____\/\\\___\/\\\_______\/\\\__/\\\/___________
-  ___\//\\\____/\\\___\/\\\\\\\\\\\/____\/\\\\\\\\\\\\\/__/\\\_____________
-   ____\//\\\__/\\\____\/\\\//////\\\____\/\\\/////////___\/\\\_____________
-    _____\//\\\/\\\_____\/\\\____\//\\\___\/\\\____________\//\\\____________
-     ______\//\\\\\______\/\\\_____\//\\\__\/\\\_____________\///\\\__________
-      _______\//\\\_______\/\\\______\//\\\_\/\\\_______________\////\\\\\\\\\_
-       ________\///________\///________\///__\///___________________\/////////__
-
-
-Enables Python3 to run VRPC as native addon.
-Author: Dr. Burkhard C. Heisen (https://github.com/bheisen/vrpc)
-
-
-Licensed under the MIT License <http://opensource.org/licenses/MIT>.
-Copyright (c) 2018 - 2021 Dr. Burkhard C. Heisen <burkhard.heisen@heisenware.com>.
-
-Permission is hereby  granted, free of charge, to any  person obtaining a copy
-of this software and associated  documentation files (the "Software"), to deal
-in the Software  without restriction, including without  limitation the rights
-to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
-copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
-IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
-FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
-AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
-LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-#include <Python.h>
-#include "vrpc.hpp"
-#include "json.hpp"
-
-#ifndef VRPC_WITH_DL
-  #include <binding.cpp>
-#endif
-
-namespace vrpc_python_bindings {
-
-  static PyObject* callRemote(PyObject* self, PyObject* args) {
-    const char* json_string;
-    // Check whether we got a string as single argument
-    if (!PyArg_ParseTuple(args, "s", &json_string)) {
-      PyErr_SetString(PyExc_TypeError, "Wrong argument type, expecting string");
-      return NULL;
-    }
-    std::string ret;
-    try {
-      ret = vrpc::LocalFactory::call(json_string);
-    } catch (const std::exception& e) {
-      PyErr_SetString(PyExc_RuntimeError, e.what());
-      return NULL;
-    }
-    return PyUnicode_FromString(ret.c_str());
-  }
-
-  static PyObject* getMemberFunctions(PyObject* self, PyObject* args) {
-    const char* class_name;
-    // Check whether we got a string as single argument
-    if (!PyArg_ParseTuple(args, "s", &class_name)) {
-      PyErr_SetString(PyExc_TypeError, "Wrong argument type, expecting string");
-      return NULL;
-    }
-    std::string ret;
-    try {
-      auto functions = vrpc::LocalFactory::get_member_functions(class_name);
-      vrpc::json j;
-      j["functions"] = functions;
-      ret = j.dump();
-    } catch (const std::exception& e) {
-      PyErr_SetString(PyExc_RuntimeError, e.what());
-      return NULL;
-    }
-    return PyUnicode_FromString(ret.c_str());
-  }
-
-  static PyObject* getStaticFunctions(PyObject* self, PyObject* args) {
-    const char* class_name;
-    // Check whether we got a string as single argument
-    if (!PyArg_ParseTuple(args, "s", &class_name)) {
-      PyErr_SetString(PyExc_TypeError, "Wrong argument type, expecting string");
-      return NULL;
-    }
-    std::string ret;
-    try {
-      auto functions = vrpc::LocalFactory::get_static_functions(class_name);
-      vrpc::json j;
-      j["functions"] = functions;
-      ret = j.dump();
-    } catch (const std::exception& e) {
-      PyErr_SetString(PyExc_RuntimeError, e.what());
-      return NULL;
-    }
-    return PyUnicode_FromString(ret.c_str());
-  }
-
-  static PyObject* callback_handler = NULL;
-
-  static void cppCallbackHandler(const vrpc::json& j) {
-    _VRPC_DEBUG << "will call back with " << j << std::endl;
-    PyObject* arglist = Py_BuildValue("(s)", j.dump().c_str());
-    PyObject* result = PyObject_CallObject(callback_handler, arglist);
-    Py_DECREF(arglist);
-  }
-
-  static PyObject* onCallback(PyObject*, PyObject* args) {
-    PyObject* result = NULL;
-    PyObject* tmp;
-
-    if (PyArg_ParseTuple(args, "O:set_callback", &tmp)) {
-      if (!PyCallable_Check(tmp)) {
-        PyErr_SetString(PyExc_TypeError, "parameter must be callable");
-        return NULL;
-      }
-      Py_XINCREF(tmp); // Add a reference to new callback
-      Py_XDECREF(callback_handler); // Dispose of previous callback
-      callback_handler = tmp; // Remember new callback
-      // Boilerplate to return "None"
-      Py_INCREF(Py_None);
-      result = Py_None;
-      // Register in vrpc
-      vrpc::Callback::register_callback_handler(
-        std::bind(cppCallbackHandler, std::placeholders::_1)
-      );
-    }
-    return result;
-  }
-
-  // Define functions in module
-  static PyMethodDef VrpcMethods[] = {
-    {
-      "callRemote",
-      callRemote,
-      METH_VARARGS,
-      "Call bound C++ function"
-    },
-    {
-      "getMemberFunctions",
-      getMemberFunctions,
-      METH_VARARGS,
-      "Lists all available member functions for requested class"
-    },
-    {
-      "getStaticFunctions",
-      getStaticFunctions,
-      METH_VARARGS,
-      "Lists all available static function for requested class"
-    },
-    {
-      "onCallback",
-      onCallback,
-      METH_VARARGS,
-      "Sets callback handler for all vrpc callbacks"
-    },
-    {NULL, NULL, 0, NULL}  // Sentinel
-  };
-
-  static struct PyModuleDef vrpc_module = {
-    PyModuleDef_HEAD_INIT,
-    // name of module
-    VRPC_MODULE_NAME,
-    // module documentation, may be NULL
-    NULL,
-    // size of per-interpreter state of the module or -1 if the module keeps state in global variables
-    -1,
-    VrpcMethods
-};
-
-  // Module initialization
-  PyMODINIT_FUNC \
-  VRPC_MODULE_FUNC(void) {
-    return PyModule_Create(&vrpc_module);
-  }
-}