def __init__(self, ip_hostname='pulsestreamer'): print("Connect to Pulse Streamer via JSON-RPC.") print("IP / Hostname:", ip_hostname) url = 'http://' + ip_hostname + ':8050/json-rpc' try: self.INFINITE = -1 self.CONSTANT_ZERO = (0, 0, 0, 0) if sys.version_info.major > 2: client = RPCClient(url) else: client = RPCClient(JSONRPCProtocol(), HttpPostClientTransport(url)) self.proxy = client.get_proxy() try: self.proxy.getSerial() except: try: self.proxy.isRunning() print( "Pulse Streamer class not compatible with current firmware. Please update your firmware." ) sys.exit(1) except: print("No Pulse Streamer found at IP/Host-address: " + ip_hostname) sys.exit(1) except: print("No Pulse Streamer found at IP/Host-address: " + ip_hostname) sys.exit(1)
def worker(*, uid: int, endpoint: str): ctx = zmq.Context() dispatcher = RPCDispatcher() client = RPCClient( JSONRPCProtocol(), ZmqClientTransport.create(ctx, endpoint), ) proxy = client.get_proxy() @dispatcher.public def do_task(): from time import sleep for i in range(5): proxy.notify(f"{uid} y{i} ") sleep(0.1) return f"OK {uid}" @dispatcher.public def exit(): proxy.exit(uid) transport = ZmqServerTransport.create( ctx, endpoint.replace(".manager", f".{uid}")) rpc_server = RPCServer(transport, JSONRPCProtocol(), dispatcher) rpc_server.trace = partial(print, file=sys.stderr) rpc_server.serve_forever()
def client(*, endpoint: str, callback_endpoint: str): ctx = zmq.Context() dispatcher = RPCDispatcher() @dispatcher.public def notify(s: str): print("** {s} **") callback_server = RPCServer( ZmqServerTransport.create(ctx, callback_endpoint), JSONRPCProtocol(), dispatcher) callback_server.trace = print threading.Thread(target=callback_server.serve_forever, daemon=True).start() rpc_client = RPCClient(JSONRPCProtocol(), ZmqClientTransport.create(ctx, endpoint)) remote_server = rpc_client.get_proxy() for i in range(7): result = remote_server.act(i, "Hello, World!") print("Server answered:", result) result = remote_server.shutdown() print("Send shutdown:", result)
def __init__(self, node_url=None): rpc_client = RPCClient( JSONRPCProtocol(), HttpPostClientTransport( node_url or os.getenv("RADIX_NODE_URL") or DEFAULT_NODE_URL ), ) self._rpc_proxy = rpc_client.get_proxy(prefix=RPC_METHOD_PREFIX)
def __init__(self,tc_service_endpoint,zmq_context): rpc_client = RPCClient( JSONRPCProtocol(), ZmqClientTransport.create(zmq_context, tc_service_endpoint) ) self._remote = rpc_client.get_proxy()
def __init__(self, obj, one_way=False): url = obj.env['device_manager.settings']._get_param( 'mqtt_rpc_bridge_url') logger.debug('HTTP bridge url {}'.format(url)) rpc_client = RPCClient( JSONRPCProtocol(), HttpPostClientTransport(url) ) self.proxy = rpc_client.get_proxy(one_way=one_way)
class RPCClientWrapper(object): def __init__(self, transport, publisher=None, ctx=None, protocol=None): self.ctx = ctx if ctx else zmq.Context().instance() if isinstance(transport, ZmqClientTransport): self.transport = transport else: if 'tcp' not in str(transport): transport = "tcp://*:" + str(transport) self.transport = ZmqClientTransport.create(self.ctx, transport) self.protocol = protocol if protocol else JSONRPCProtocol() self.publisher = publisher if publisher else NoOpPublisher() self.transport.publisher = self.publisher self.rpc_client = RPCClient(self.protocol, self.transport, self.publisher, retries=0) self.proxy = self.get_proxy() def get_proxy(self, prefix=''): return self.rpc_client.get_proxy(prefix) def hijack(self, mock, func=None): self.rpc_client._send_and_handle_reply = mock def __getattr__(self, attr): logging.info('RPC call: {}'.format(attr)) return getattr(self.proxy, attr) def get_result(self, uid=None): return self.rpc_client.get_result(uid) def get_status(self, uid=None): return self.rpc_client.get_status(uid) def wait_for_task(self, uid=None): self.rpc_client.wait_for_task(uid) def reset(self): self.rpc_client.reset() def send_file(self, *args, **kwargs): return self.rpc_client.send_file(*args, **kwargs) def get_file(self, *args, **kwargs): return self.rpc_client.get_file(*args, **kwargs) def get_and_write_file(self, *args, **kwargs): return self.rpc_client.get_and_write_file(*args, **kwargs)
def __init__(self, transport, publisher=None, ctx=None, protocol=None): self.ctx = ctx if ctx else zmq.Context().instance() if isinstance(transport, ZmqClientTransport): self.transport = transport else: if 'tcp' not in str(transport): transport = "tcp://*:" + str(transport) self.transport = ZmqClientTransport.create(self.ctx, transport) self.protocol = protocol if protocol else JSONRPCProtocol() self.publisher = publisher if publisher else NoOpPublisher() self.transport.publisher = self.publisher self.rpc_client = RPCClient(self.protocol, self.transport, self.publisher) self.proxy = self.get_proxy()
def setUpClass(cls): cls.context = zmq.Context() cls.subscriber = cls.context.socket(zmq.SUB) cls.remote_server = None cls.subscriber.connect("tcp://%s:5500" % HOST) cls.subscriber.setsockopt(zmq.SUBSCRIBE, "DEFAULT") cls.subscriber.setsockopt(zmq.SUBSCRIBE, "SUB_KEY") rpc_client = RPCClient( JSONRPCProtocol(), HttpPostClientTransport("http://%s:5501" % HOST)) cls.remote_server = rpc_client.get_proxy() # Cross-test variables cls.coflow_id = ""
def __init__(self, address='192.168.1.100'): if (toolbox.validate_ip(address)): self.ip = address self.url = 'http://' + self.ip + ':8050/json-rpc' try: self.client = RPCClient(JSONRPCProtocol(), HttpPostClientTransport(self.url)) except: print('Error: cannot create RPC client!') try: self.ps = self.client.get_proxy() except: print('Error: cannot create proxy connection!') else: print("IP address not valid!")
def client(*, endpoint: str): from tinyrpc.transports.zmq import ZmqClientTransport from tinyrpc import RPCClient ctx = zmq.Context() rpc_client = RPCClient(JSONRPCProtocol(), ZmqClientTransport.create(ctx, endpoint)) remote_server = rpc_client.get_proxy() for i in range(7): result = remote_server.act(i, "Hello, World!") print("Server answered:", result) result = remote_server.shutdown() print("Send shutdown:", result)
def __init__(self, ip_hostname='pulsestreamer'): print("Connect to Pulse Streamer via JSON-RPC.") print("IP / Hostname:", ip_hostname) self.ip_address = ip_hostname url = 'http://' + ip_hostname + ':8050/json-rpc' try: client = RPCClient(JSONRPCProtocol(), HttpPostClientTransport(url, timeout=20)) self.proxy = client.get_proxy() try: self.proxy.getSerial() except: try: self.proxy.isRunning() assert False, "Pulse Streamer class not compatible with current firmware. Please update your firmware." \ "For detailed information visit https://www.swabianinstruments.com/pulse-streamer-8-2-firmware/ " \ "or contact [email protected]" except AssertionError: raise except: assert False, "No Pulse Streamer found at IP/Host-address: " + ip_hostname except AssertionError: raise except: assert False, "No Pulse Streamer found at IP/Host-address: " + ip_hostname firmware_version = self.proxy.getFirmwareVersion() self.__version_1_1_or_higher = True if _compare_version_number( firmware_version, '1.1.0') >= 0 else False print("Pulse Streamer 8/2 firmware: v" + firmware_version) print("Client software: v" + __CLIENT_VERSION__) if (_compare_version_number(firmware_version) >= 0): print( "The Pulse Streamer 8/2 firmware is more up to date than your client software. We recommend to update your client software." ) print( "For detailed information visit https://www.swabianinstruments.com/support/downloads/ or contact [email protected]" ) elif (_compare_version_number( '.'.join(__CLIENT_VERSION__.split('.')[0:2] + ['0']), '.'.join(firmware_version.split('.')[0:2] + ['0'])) > 0): print( "Your client software is more up to date than the Pulse Streamer 8/2 firmware. We recommend to update the firmware of your Pulse Streamer 8/2." ) print( "For detailed information visit https://www.swabianinstruments.com/support/downloads/ or contact [email protected]" )
def setUpClass(cls): cls.context = zmq.Context() cls.subscriber = cls.context.socket(zmq.SUB) cls.remote_server = None cls.subscriber.connect("tcp://%s:5500" % HOST) cls.subscriber.setsockopt(zmq.SUBSCRIBE, "DEFAULT") cls.subscriber.setsockopt(zmq.SUBSCRIBE, "SUB_KEY") rpc_client = RPCClient( JSONRPCProtocol(), HttpPostClientTransport("http://%s:5501" % HOST) ) cls.remote_server = rpc_client.get_proxy() # Cross-test variables cls.coflow_id = ""
def __init__(self, modbus_service_endpoint, device_id, zmq_context=None): self.device_id = device_id if zmq_context is None: self.zmq_context = zmq.Context() else: self.zmq_context = zmq_context self._rpc_client = RPCClient( JSONRPCProtocol(), ZmqClientTransport.create(self.zmq_context, modbus_service_endpoint) ) self.modbus_proxy = self._rpc_client.get_proxy()
def __init__(self, zmq_context, source, destination, n_bytes): threading.Thread.__init__(self) self.key = "SENDER%i" % Sender.count Sender.count += 1 self.subscriber = zmq_context.socket(zmq.SUB) self.subscriber.connect("tcp://%s:5500" % HOST) self.subscriber.setsockopt(zmq.SUBSCRIBE, self.key) rpc_client = RPCClient( JSONRPCProtocol(), HttpPostClientTransport("http://%s:5501" % HOST)) self.remote_server = rpc_client.get_proxy() self.source = source self.destination = destination self.n_bytes = n_bytes self.result = ""
def __init__(self, zmq_context, source, destination, n_bytes): threading.Thread.__init__(self) self.key = "SENDER%i" % Sender.count Sender.count += 1 self.subscriber = zmq_context.socket(zmq.SUB) self.subscriber.connect("tcp://%s:5500" % HOST) self.subscriber.setsockopt(zmq.SUBSCRIBE, self.key) rpc_client = RPCClient( JSONRPCProtocol(), HttpPostClientTransport("http://%s:5501" % HOST) ) self.remote_server = rpc_client.get_proxy() self.source = source self.destination = destination self.n_bytes = n_bytes self.result = ""
def run() -> None: ctx = zmq.Context() port = _find_free_port() sentinel = tempfile.mktemp() cmd = [ sys.executable, "03server.py", "--port", str(port), "--sentinel", sentinel ] with connect_server(cmd, sentinel=sentinel, port=port): print(f"connect ... {port}", file=sys.stderr) rpc_client = RPCClient( JSONRPCProtocol(), ZmqClientTransport.create(ctx, f"tcp://127.0.0.1:{port}")) s = rpc_client.get_proxy() print("Returns 2**3 = 8", "->", s.pow(2, 3)) print("Returns 5", "->", s.add(2, 3)) print("Returns 5*2 = 10", "->", s.mul(5, 2)) # Print list of available methods print(s.list_methods())
class TemperatureControllerService(object): def __init__(self, modbus_service_endpoint, device_id, zmq_context=None): self.device_id = device_id if zmq_context is None: self.zmq_context = zmq.Context() else: self.zmq_context = zmq_context self._rpc_client = RPCClient( JSONRPCProtocol(), ZmqClientTransport.create(self.zmq_context, modbus_service_endpoint) ) self.modbus_proxy = self._rpc_client.get_proxy() @public def get_pv(self): return self.modbus_proxy.get_pv(self.device_id); @public def get_working_setpoint(self): return self.modbus_proxy.get_working_setpoint(self.device_id); @public def get_setpoint1(self): return self.modbus_proxy.get_setpoint1(self.device_id); @public def get_setpoint2(self): return self.modbus_proxy.get_setpoint2(self.device_id) @public def set_setpoint1(self, value): return self.modbus_proxy.set_setpoint1(self.device_id, value); @public def set_setpoint2(self, value): return self.modbus_proxy.set_setpoint2(self.device_id, value); @public def set_remote_setpoint(self,value): return self.modbus_proxy.set_remote_setpoint(self.device_id, value); @public def get_status(self): return self.modbus_proxy.get_status(self.device_id)
def __init__(self, args): cmd2.Cmd.__init__(self) self.prompt = "\n\033[1;33m# \033[0m" self.args = args uri = ''.join( ["http://", args['--host'], ":", args['--port'], "/jsonrpc"]) rpc_client = RPCClient(JSONRPCProtocol(), HttpPostClientTransport(uri)) self.xbmc = rpc_client self.input = namespaces.Input(self.xbmc) self.gui = namespaces.GUI(self.xbmc) self.jsonrpc = namespaces.JSONRPC(self.xbmc) self.video_library = namespaces.VideoLibrary(self.xbmc) self.player = namespaces.Player(self.xbmc)
from tinyrpc.server.gevent import RPCServerGreenlets from tinyrpc.dispatch import RPCDispatcher from tinyrpc import RPCClient import rospy import statecodes from prac2cram.msg import CRAMTick from prac2cram.srv import Prac2Cram, CancelSim from p2c_rosaux import getROSTasks, getStringList portOffsNum = int(sys.argv[1]) rpcPort = int(sys.argv[2]) instPort = int(sys.argv[3]) instURL = "http://localhost:" + str(instPort) instClient = RPCClient(JSONRPCProtocol(), HttpPostClientTransport(instURL)) instRPC = instClient.get_proxy() parentURL = None parentClient = None parentRPC = None if (4 < len(sys.argv)): parentURL = sys.argv[4] parentClient = RPCClient(JSONRPCProtocol(), HttpPostClientTransport(parentURL)) parentRPC = parentClient.get_proxy() ownId = portOffsNum if (5 < len(sys.argv)): ownId = sys.argv[5] simRunning = False
#!/usr/bin/python # # pip install tinyrpc # from tinyrpc.protocols.jsonrpc import JSONRPCProtocol from tinyrpc.transports.http import HttpPostClientTransport from tinyrpc import RPCClient rpc_client = RPCClient( JSONRPCProtocol(), HttpPostClientTransport('http://localhost:8080/') ) local = rpc_client.get_proxy() s=' This is a message ' stripped = local.strip(str=s) assert stripped == s.strip() print 'rpc ok' import sys sys.exit(0)
#!/usr/bin/python # # pip install tinyrpc # from tinyrpc.protocols.jsonrpc import JSONRPCProtocol from tinyrpc.transports.http import HttpPostClientTransport from tinyrpc import RPCClient rpc_client = RPCClient(JSONRPCProtocol(), HttpPostClientTransport('http://localhost:8080/')) local = rpc_client.get_proxy() s = ' This is a message ' stripped = local.strip(str=s) assert stripped == s.strip() print 'rpc ok' import sys sys.exit(0)
''' refer : https://github.com/mbr/tinyrpc/tree/master/examples import gevent import tinyrpc import gevent-websocket ''' from tinyrpc.protocols.jsonrpc import JSONRPCProtocol from tinyrpc.transports.http import HttpPostClientTransport from tinyrpc import RPCClient rpc_client = RPCClient(JSONRPCProtocol(), HttpPostClientTransport('http://127.0.0.1:5000/')) remote_server = rpc_client.get_proxy() # call a method called 'reverse_string' with a single string argument result = remote_server.reverse_string('Hello, World!') print("Server answered: ", result)
import zmq from tinyrpc.protocols.jsonrpc import JSONRPCProtocol from tinyrpc.transports.zmq import ZmqClientTransport from tinyrpc import RPCClient ctx = zmq.Context() rpc_client = RPCClient(JSONRPCProtocol(), ZmqClientTransport.create(ctx, 'tcp://127.0.0.1:5050')) remote_server = rpc_client.get_proxy() remote_server.gotoStopState() print remote_server.getState()
import zmq import time from tinyrpc.protocols.jsonrpc import JSONRPCProtocol from tinyrpc.transports.zmq import ZmqClientTransport from tinyrpc import RPCClient ctx = zmq.Context() rpc_client = RPCClient( JSONRPCProtocol(), ZmqClientTransport.create(ctx, 'tcp://127.0.0.1:5062') ) remote_server = rpc_client.get_proxy() for i in range(1000): print remote_server.get_pv()
def __init__(self, transport=None, publisher=None, ctx=None, protocol=None, ip=None, port=None, receiver_port=None): self.ctx = ctx if ctx else zmq.Context().instance() msg = 'ip and port should be used together.' assert ([ip, port] == [None, None]) or (ip is not None and port is not None), msg if ip is not None and port is not None: msg = 'port {} invalid; please choose from (0, 65536)'.format(port) assert 0 < port < 65536, msg # user provide ip and port, assuming using tcp. # endpoint generated as 'tcp' # user should not pass another transport in. msg = 'transport cannot be used along with ip&port' assert transport is None, msg assert isinstance(ip, basestring) msg = 'invalid tcp port: {}'.format(port) assert isinstance(port, int) and 0 < port < 65536, msg # generate zmq endpoint from ip and port if receiver_port is None: receiver_port = port + 10000 # ensure receiver_port is valid msg = ('Failed to generate receiver_port by 10000 + port {}; ' 'please use port < 55536') assert receiver_port < 65536, msg.format(port) else: msg = 'receiver_port {} invalid; please choose from (0, 65536)'.format( receiver_port) assert 0 < receiver_port < 65536, msg transport = { 'requester': 'tcp://{}:{}'.format(ip, port), 'receiver': 'tcp://{}:{}'.format(ip, receiver_port) } if isinstance(transport, ZmqClientTransport): self.transport = transport elif isinstance(transport, dict): # dictionary: if 'requester' in transport and 'receiver' in transport: self.transport = ZmqClientTransport.create(self.ctx, transport) else: msg = 'endpoint dictionary {} should contains requester and receiver' raise Exception(msg.format(transport)) elif isinstance(transport, basestring): # only 1 endpoint is provided; create endpoint for receiver by adding port by 10000 pattern = '(tcp://)?((?P<ip>[0-9.*]+):)?(?P<port>[0-9]+)' re_groups = re.match(pattern, transport.strip()) if not re_groups: raise Exception('Invalid RPC client endpoint format {}; ' 'expecting tcp://IP:PORT'.format(transport)) requester_port = int(re_groups.group('port')) ip = re_groups.group('ip') endpoints = { 'requester': 'tcp://{}:{}'.format(ip, requester_port), 'receiver': 'tcp://{}:{}'.format(ip, requester_port + 10000) } self.transport = ZmqClientTransport.create(self.ctx, endpoints) else: msg = 'RPC client endpoint {} not supported; expecting dict or string or ip&port.' raise Exception(msg.format(transport)) self.protocol = protocol if protocol else JSONRPCProtocol() self.publisher = publisher if publisher else NoOpPublisher() self.transport.publisher = self.publisher self.rpc_client = RPCClient(self.protocol, self.transport, self.publisher) self.proxy = self.rpc_client.get_proxy()
from tinyrpc.protocols.jsonrpc import JSONRPCProtocol from tinyrpc.transports.http import HttpPostClientTransport from tinyrpc import RPCClient import time import sys rpc_client = RPCClient(JSONRPCProtocol(), HttpPostClientTransport('http://192.168.1.100:8080/')) remote_server = rpc_client.get_proxy() try: vhf_data_rate = None uhf_data_rate = None sat_comm_data_rate = None while True: time.sleep(2) vhf_data_rate_json = remote_server.get_vhf_data_rate() vhf_data_rate = vhf_data_rate_json['vhf_rate'] uhf_data_rate_json = remote_server.get_uhf_data_rate() uhf_data_rate = uhf_data_rate_json['uhf_rate'] sat_comm_data_rate_json = remote_server.get_sat_comm_data_rate() sat_comm_data_rate = sat_comm_data_rate_json['satcomm_rate'] print("\n\n\nCurrent VHF data rate is: ", vhf_data_rate) print("\n\n\nCurrent UHF data rate is: ", uhf_data_rate) print("\n\n\nCurrent SatComm data rate is: ", sat_comm_data_rate) except KeyboardInterrupt:
dest='outfile', type=str, default=None, help='A file to write the analog input values to (csv)') parser.add_argument('--interval', dest='interval', type=int, default=1, help="The time between samples in seconds") args = parser.parse_args() ctx = zmq.Context() rpc_client = RPCClient(JSONRPCProtocol(), ZmqClientTransport.create(ctx, endpoint=args.endpoint)) remote_server = rpc_client.get_proxy() # call a method called 'reverse_string' with a single string argument channels = range(8) if (args.outfile is not None): with file(args.outfile, 'w') as f: f.write(",".join(["datetime"] + ["ai%i" % ch for ch in channels]) + "\n") while True: results = [] now = datetime.datetime.now()
* we assume the timetagger webserver has been started on the same host (localhost) * we use the tinyrpc python package that allows us to represent the timetagger webserver as a python class and will hide all JSON-RPC details from us. * The methods of this 'proxy class' are equivalent to the JSON-RPC interface """ #from jsonrpc import ServiceProxy #timetagger = ServiceProxy('http://localhost:8080/json-rpc') from tinyrpc.protocols.jsonrpc import JSONRPCProtocol from tinyrpc.transports.http import HttpPostClientTransport from tinyrpc import RPCClient rpc_client = RPCClient( JSONRPCProtocol(), HttpPostClientTransport('http://localhost:8080/json-rpc')) # create the proxy class timetagger = rpc_client.get_proxy() timetagger.getSystemInfo() timetagger.scanDevices() res = timetagger.getDeviceList() dev_id = res[0]['id'] # dev_id = '12520004J3' # FPGA serial number res = timetagger.getModuleList(device=dev_id) mod_id = res[0][ 'id'] # mod_id = 'ID-000001' # module created in web application beforehand
#!/usr/bin/env python # -*- coding: utf-8 -*- """Example RPC client for controlling a wotabag. Requires tinrypc[httpclient] (https://github.com/mbr/tinyrpc). """ import time from tinyrpc.protocols.jsonrpc import JSONRPCProtocol from tinyrpc.transports.http import HttpPostClientTransport from tinyrpc import RPCClient rpc_client = RPCClient( JSONRPCProtocol(), HttpPostClientTransport('http://raspberrypi.local:60715/')) server = rpc_client.get_proxy(prefix='wotabag.') # Retrieve server status result = server.get_status() print(result) # Retrieve server playlist result = server.get_playlist() print(result) # Test LED patterns server.test_pattern()
def main(): try: # s = socket.socket() # Create a socket object # host = socket.gethostname() # Get local machine name # port = 55555 # Reserve a port for your service. # s.bind((host, port)) # Bind to the port # # s.listen(5) # Now wait for client connection. # # nt = Thread(target=network_server, args=(s,)) # nt.daemon = True # thread dies with the program # nt.start() ctx = zmq.Context() rpc_client = RPCClient( JSONRPCProtocol(), ZmqClientTransport.create(ctx, SERVER_ADDR) ) remote_server = rpc_client.get_proxy() tv_controller = rpc_client.get_proxy("tv_controller.") ############################# # Runtime Loop global sleepActive sleepActive = False global timeout global lastNetwork timeout = 0 lastNetwork = time.time() playstate = 'idle' prevplaystate = playstate lastStat = time.time() last_mythtv_status = False last_xbmc_status = False mythtvStatus = mythtv_status.mythtv_status() keyPressTimeout = time.time() - TIMEOUT + 90 # Start with 1.5 minute to sleep timeSinceComms = time.time() - RESEND_TIMEOUT + 20 while True: if not resetQueue.empty(): resetQueue.get(timeout=10) keyPressTimeout = time.time() if (time.time() - lastStat) > 60: logger.debug("idleTime: " + str((time.time() - keyPressTimeout)/60)) lastStat = time.time() # Monitor MythTV current_mythtv_status = mythtvStatus.getStatus() if current_mythtv_status: if not last_mythtv_status: logger.debug("mythtv start playing") keyPressTimeout = time.time() elif last_mythtv_status: logger.debug("mythtv stop playing") last_mythtv_status = current_mythtv_status # Monitor XBMC try: current_xbmc_status = xbmc_status.getStatus() if current_xbmc_status: if not last_xbmc_status: logger.debug("xbmc start playing") keyPressTimeout = time.time() elif last_xbmc_status: logger.debug("xbmc stop playing") last_xbmc_status = current_xbmc_status except xbmc_status.Timeout: pass now = time.time() currSleep = (now - keyPressTimeout) > TIMEOUT if (now - timeSinceComms > RESEND_TIMEOUT) or (currSleep != sleepActive): timeSinceComms = now sleepActive = currSleep logger.debug("Sending Status: " + ("off" if sleepActive else "on")) result = tv_controller.SetPowerStatus(not sleepActive) logger.debug(result) # if (time.time() - keyPressTimeout) > TIMEOUT: # # Go To Sleep # if not sleepActive: # print "Sleep" # logger.debug("timeout: sleep") # sleepActive = True # result = tv_controller.SetPowerStatus('on' if sleepActive else 'off') # logger.debug(result) # # # # Comms has dropped out, let system service manager restart # # if time.time() - lastNetwork > TIMEOUT: # # exit() # # else: # if sleepActive: # print "Wake" # logger.debug("timeout: wake") # sleepActive = False # result = tv_controller.SetPowerStatus(False if sleepActive else True) # logger.debug(result) time.sleep(0.5) except Exception as e: logger.warn("exception in main()") logger.exception(e)
def server(*, endpoint: str, callback_endpoint: str): q = queue.Queue() ev = threading.Event() ctx = zmq.Context() dispatcher = RPCDispatcher() rpc_server = RPCServer(ZmqServerTransport.create(ctx, endpoint), JSONRPCProtocol(), dispatcher) rpc_server.trace = print # client callback_client = RPCClient( JSONRPCProtocol(), ZmqClientTransport.create(ctx, callback_endpoint)) callback_remote_server = callback_client.get_proxy(one_way=True) running = True @dispatcher.public def act(uid: int, s: str) -> str: q.put(("act", (uid, s), {})) ev.set() return "ok" @dispatcher.public def shutdown() -> None: nonlocal running running = False def do_act(uid: int, s: str) -> Future: fut = Future() def do(): for i in range(5): callback_remote_server.notify(f"{uid:02d}: {i} {s}") print(f"{uid:02d}: {i} {s}") time.sleep(0.1) fut.set_result(("ok", uid)) threading.Thread(target=do, daemon=True).start() return fut def do_server(): nonlocal running while running: rpc_server.receive_one_message() def do_loop(*, ns): nonlocal running while running: fn, args, kwargs = q.get() fut = ns[f"do_{fn}"](*args, **kwargs) def cont(fut): q.task_done() fut.add_done_callback(cont) ns = locals() th = threading.Thread(target=do_loop, kwargs={"ns": ns}, daemon=True) th.start() th2 = threading.Thread(target=do_server, daemon=True) th2.start() ev.wait() q.join()
import zmq from tinyrpc.protocols.jsonrpc import JSONRPCProtocol from tinyrpc.transports.zmq import ZmqClientTransport from tinyrpc import RPCClient import numpy as np import time ctx = zmq.Context() rpc_client = RPCClient( JSONRPCProtocol(), ZmqClientTransport.create(ctx, 'tcp://127.0.0.1:10101') ) basler = rpc_client.get_proxy()
import rospy # interface with knowledge import rosprolog_client # Messages import actionlib import nlg_msgs.msg # connection to nlg.py3 script import zmq from tinyrpc import RPCClient, RPCProxy from tinyrpc.protocols.jsonrpc import JSONRPCProtocol from tinyrpc.transports.zmq import ZmqClientTransport from std_msgs.msg import String # Start an RPC Client rpc_client = RPCClient( JSONRPCProtocol(), ZmqClientTransport.create(zmq.Context(), 'tcp://127.0.0.1:5002')) gen_server = None prolog = rosprolog_client.Prolog() class NlgAction: # create messages that are used to publish feedback/result _feedback = nlg_msgs.msg.LanguageGenerationFeedback() _result = nlg_msgs.msg.LanguageGenerationResult() def __init__(self, name): self._action_name = name self._as = actionlib.SimpleActionServer( self._action_name,
class RPCClientWrapper(object): ''' RPC Client class for user. RPCClient needs to connect to 2 sockets on server: one for sending request (requester); the other for receiving reply (receiver), defaults to requestor + 10000 Typical usage: # most commonly used # this implies using server's 7801 and 17801 port; # work when server is created as RPCServer('tcp://169.254.1.32:7801') rpc_client = RPCClientWrapper('tcp://169.254.1.32:7801') # this implies using tcp. rpc_client = RPCClientWrapper(ip='169.254.1.32', port=7801) Supported as conner case: # when need to specify a non-default receiver_port: rpc_client = RPCClientWrapper(ip='169.254.1.32', port=7801, receiver_port=20000) Sending RPC: With rpc client instantiated, it can access any rpc server registered on server with syntax client.INSTANCE_NAME.RPC_FUNCTION_NAME Example: # server has "server" instances registered with "mode" rpc API: rpc_client.server.mode() ''' def __init__(self, transport=None, publisher=None, ctx=None, protocol=None, ip=None, port=None, receiver_port=None): self.ctx = ctx if ctx else zmq.Context().instance() msg = 'ip and port should be used together.' assert ([ip, port] == [None, None]) or (ip is not None and port is not None), msg if ip is not None and port is not None: msg = 'port {} invalid; please choose from (0, 65536)'.format(port) assert 0 < port < 65536, msg # user provide ip and port, assuming using tcp. # endpoint generated as 'tcp' # user should not pass another transport in. msg = 'transport cannot be used along with ip&port' assert transport is None, msg assert isinstance(ip, basestring) msg = 'invalid tcp port: {}'.format(port) assert isinstance(port, int) and 0 < port < 65536, msg # generate zmq endpoint from ip and port if receiver_port is None: receiver_port = port + 10000 # ensure receiver_port is valid msg = ('Failed to generate receiver_port by 10000 + port {}; ' 'please use port < 55536') assert receiver_port < 65536, msg.format(port) else: msg = 'receiver_port {} invalid; please choose from (0, 65536)'.format( receiver_port) assert 0 < receiver_port < 65536, msg transport = { 'requester': 'tcp://{}:{}'.format(ip, port), 'receiver': 'tcp://{}:{}'.format(ip, receiver_port) } if isinstance(transport, ZmqClientTransport): self.transport = transport elif isinstance(transport, dict): # dictionary: if 'requester' in transport and 'receiver' in transport: self.transport = ZmqClientTransport.create(self.ctx, transport) else: msg = 'endpoint dictionary {} should contains requester and receiver' raise Exception(msg.format(transport)) elif isinstance(transport, basestring): # only 1 endpoint is provided; create endpoint for receiver by adding port by 10000 pattern = '(tcp://)?((?P<ip>[0-9.*]+):)?(?P<port>[0-9]+)' re_groups = re.match(pattern, transport.strip()) if not re_groups: raise Exception('Invalid RPC client endpoint format {}; ' 'expecting tcp://IP:PORT'.format(transport)) requester_port = int(re_groups.group('port')) ip = re_groups.group('ip') endpoints = { 'requester': 'tcp://{}:{}'.format(ip, requester_port), 'receiver': 'tcp://{}:{}'.format(ip, requester_port + 10000) } self.transport = ZmqClientTransport.create(self.ctx, endpoints) else: msg = 'RPC client endpoint {} not supported; expecting dict or string or ip&port.' raise Exception(msg.format(transport)) self.protocol = protocol if protocol else JSONRPCProtocol() self.publisher = publisher if publisher else NoOpPublisher() self.transport.publisher = self.publisher self.rpc_client = RPCClient(self.protocol, self.transport, self.publisher) self.proxy = self.rpc_client.get_proxy() def hijack(self, mock, func=None): self.rpc_client._send_and_handle_reply = mock def __getattr__(self, attr): ''' Handle client_wrapper.attr Calling rpc_client method for some function Create proxy otherwise. This enables client.driver.func() which is previously not supported. Args: attr: attribute in string; could be function name or proxy name. Returns: self.rpc_client function for items in list; proxy otherwise. ''' pass_through_apis = [ 'get_proxy', 'set_profile', 'set_profile', 'clear_profile_stats', 'send_file', 'get_file', 'get_log', 'get_linux_boot_log', 'get_and_write_file', 'get_and_write_log', 'get_and_write_all_log', 'call', ] if attr in pass_through_apis: return getattr(self.rpc_client, attr) logging.info('Getting proxy: {}'.format(attr)) return self.rpc_client.get_proxy(attr) def rpc(self, method, *args, **kwargs): ''' interface for calling rpc using full rpc name as string like "driver.func" Args: method: string of rpc service name; format: instance.function for instance methods function for standalone functions. *args: list of un-named arguments of given method **kwargs: dict of keyword arguments of given method ''' return self.rpc_client.call(method, *args, **kwargs)
from tinyrpc.protocols.jsonrpc import JSONRPCProtocol from tinyrpc.transports.http import HttpPostClientTransport from tinyrpc import RPCClient rpc_client = RPCClient( JSONRPCProtocol(), HttpPostClientTransport('http://localhost:5000/v1/jsonrpc') ) rpc_server = rpc_client.get_proxy() print "pinging..." pong = rpc_server.ping() print "ping response: " + pong resp = rpc_server.hello("Ashutosh") print "hello world response: " + resp
def manager(): @dataclasses.dataclass class Handler: uid: int process: subprocess.Popen remote_server: RPCProxy ctx = zmq.Context() dispatcher = RPCDispatcher() living_process = {None} # None is semaphore @dispatcher.public def notify(msg: t.Any): print("*", msg, "*") @dispatcher.public def exit(uid: int): print("EXIT", living_process.remove(uid)) # use tmpfs? with tempfile.TemporaryDirectory() as d: endpoint = f"ipc://{d}/worker.manager" transport = ZmqServerTransport.create(ctx, endpoint) rpc_server = RPCServer(transport, JSONRPCProtocol(), dispatcher) def server_loop(): while len(living_process) > 0: rpc_server.receive_one_message() th = threading.Thread(target=server_loop, daemon=True) th.start() handlers = [] n = 3 protocol = JSONRPCProtocol() for uid in range(n): living_process.add(uid) cmd = [ sys.executable, "-u", __file__, "worker", "--uid", str(uid), "--endpoint", endpoint, ] p = subprocess.Popen( cmd, # stdout=subprocess.PIPE, # stderr=subprocess.PIPE, # text=False, # for read1 ) rpc_client = RPCClient( protocol, ZmqClientTransport.create( ctx, endpoint.replace(".manager", f".{uid}")), ) remote_server = rpc_client.get_proxy() handlers.append( Handler(uid=uid, process=p, remote_server=remote_server)) # 本当はguardなどを使う living_process.remove(None) # None is semaphore futs = [] from concurrent.futures import ThreadPoolExecutor with ThreadPoolExecutor() as ex: for h in handlers: futs.append(ex.submit(h.remote_server.do_task)) futs.append(ex.submit(h.remote_server.do_task)) for fut in futs: print(fut.result()) for h in handlers: h.remote_server.exit() print("END") th.join()
newAlias = createId() cmdStr = 'python sim_inst_mngr.py ' + str(k) + ' ' + str(p) + ' ' + str(ownPort) + ' ' + str(newId) print 'Opening subprocess ' + cmdStr childIds.append(newId) child2PackageMap[newId] = p childStates[newId] = statecodes.SC_BOOTING childAliases[newId] = newAlias childAlias2Id[newAlias] = newId nThread = Thread(target=execute_command, args=(cmdStr,)) childThreads.append(nThread) nThread.setDaemon(True) nThread.start() print 'Connecting to that instance\'s RPC scripts' #TODO: for now we can assume these are localhost, but maybe in the future we will need more sophistication here rpcURL = "http://localhost:" + str(5050 + k) rpcClient = RPCClient(JSONRPCProtocol(), HttpPostClientTransport(rpcURL)) childRPC = rpcClient.get_proxy() childRPCNodes[newId] = rpcClient childRPCs[newId] = childRPC instURL = "http://localhost:" + str(5150 + k) instClient = RPCClient(JSONRPCProtocol(), HttpPostClientTransport(instURL)) instRPC = instClient.get_proxy() childInstRPCNodes[newId] = instClient childInstRPCs[newId] = instRPC def exit_gracefully(sig, frame): for s in subprocesses: os.killpg(os.getpgid(s.pid), signal.SIGTERM) sys.exit(0) signal.signal(signal.SIGINT, exit_gracefully) signal.signal(signal.SIGTERM, exit_gracefully)
class PulseStreamer(): #Class for Pulse Streamer 8/2, Swabian Instruments def __init__(self, address='192.168.1.100'): if (toolbox.validate_ip(address)): self.ip = address self.url = 'http://' + self.ip + ':8050/json-rpc' try: self.client = RPCClient(JSONRPCProtocol(), HttpPostClientTransport(self.url)) except: print('Error: cannot create RPC client!') try: self.ps = self.client.get_proxy() except: print('Error: cannot create proxy connection!') else: print("IP address not valid!") def load_sequence(self, sequence): self.sequence = sequence def generate_random_seq(self, min_len=0, max_len=1024, n_pulses=1000): ttt = np.random.uniform(min_len, max_len, n_pulses).astype(int) t = [int(x) for x in ttt] print(t) seq = [(8, 1, 0, 0)] # 8 ns trigger pulse on channel 0 for i, ti in enumerate(t): state = int(i % 2) sss = [(int(ti), int(0xfe * state), int(0x7fff * state), -int(0x7fff * state))] print(sss) seq += sss print(seq) return seq def encode(self, seq): """ Convert a human-readable python sequence to a base64-encoded string """ s = b'' for pulse in seq: print('pulse', pulse) s += struct.pack('>IBhh', *pulse) return base64.b64encode(s) def set_parameters(self, n_runs=-1, initial=(0, 0xff, 0, 0), final=(0, 0x00, 0x7fff, 0), underflow=(0, 0, 0, 0), start='IMMEDIATE'): self.n_runs = n_runs self.initial = initial self.final = final self.underflow = underflow self.start = start def start_stream(self): self.ps.stream(self.encode(self.sequence), self.n_runs, self.initial, self.final, self.underflow, self.start) def isRunning(self): if (self.ps.isRunning() == 1): print('Yes') else: print('No') def stop(self): self.ps.stream([0, 0, 0, 0]) if (self.ps.isRunning() == 0): print('Pulse Streamer stopped')