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,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, 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 worker():
ctx = zmq.Context()
rpc_client = RPCClient(
JSONRPCProtocol(),
ZmqClientTransport.create(ctx, "tcp://127.0.0.1:5002"))
proxy = rpc_client.get_proxy()
for message in iter(partial(recv, port=sys.stdin), ""):
proxy.post(f"hello {message}")
import time
time.sleep(0.4)
sys.stdout.write("")
sys.stdout.close()
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 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 transport(request, zmq_context, zmq_green_context):
if request.param == 'dummy':
server = DummyServerTransport()
client = DummyClientTransport(server)
elif request.param in ('zmq', 'zmq.green'):
ctx = zmq_context if request.param == 'zmq' else zmq_green_context
server = ZmqServerTransport.create(ctx, ZMQ_ENDPOINT)
client = ZmqClientTransport.create(ctx, ZMQ_ENDPOINT)
def fin():
server.socket.close()
client.socket.close()
request.addfinalizer(fin)
else:
raise ValueError('Invalid transport.')
return (client, server)
def transport(request, zmq_context, zmq_green_context):
if request.param == 'dummy':
server = DummyServerTransport()
client = DummyClientTransport(server)
elif request.param in ('zmq', 'zmq.green'):
ctx = zmq_context if request.param == 'zmq' else zmq_green_context
server = ZmqServerTransport.create(ctx, ZMQ_ENDPOINT_SERVER)
client = ZmqClientTransport.create(ctx, ZMQ_ENDPOINT_CLIENT)
def fin():
server.shutdown()
client.shutdown()
request.addfinalizer(fin)
else:
raise ValueError('Invalid transport.')
return (client, server)
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()
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()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
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:5001"))
remote_server = rpc_client.get_proxy()
for i in range(10):
# call a method called 'reverse_string' with a single string argument
result = remote_server.reverse_string("Hello, World!")
print("Server answered:", result)
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()
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()
# 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,
nlg_msgs.msg.LanguageGenerationAction,
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')
)
remote_server = rpc_client.get_proxy()
i=0
while True:
try:
print remote_server.knaker(test=i)
except:
pass
# call a method called 'reverse_string' with a single string argument
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()
help='The server address')
parser.add_argument('--outfile', 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 = []
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)