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')
