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, 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)
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 __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 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 __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)
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())
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()
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()
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
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
'''
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)
#!/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)
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()
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:
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,
#!/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 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()