def __init__(self, ws, rpc_callback):
dispatcher = RPCDispatcher()
dispatcher.register_instance(rpc_callback)
super(WebSocketRPCServer, self).__init__(
WebSocketServerTransport(ws),
JSONRPCProtocol(),
dispatcher,
)
def __init__(self, ws, rpc_callback):
dispatcher = RPCDispatcher()
dispatcher.register_instance(rpc_callback)
super(WebSocketRPCServer, self).__init__(
WebSocketServerTransport(ws),
JSONRPCProtocol(),
dispatcher,
)
def connectHandler(cmd, handler):
dispatcher = RPCDispatcher()
print("cmd: {}".format(" ".join(cmd)))
# line buffered
p = subprocess.Popen(cmd,
bufsize=1,
universal_newlines=True,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
transport = PipeTransport(p.stdout, p.stdin)
rpc_server = RPCServer(transport, JSONRPCProtocol(), dispatcher)
dispatcher.register_instance(handler, '')
return (rpc_server, p)
def main(args):
cmd = ["clef", "--stdio-ui"]
if len(args) > 0 and args[0] == "test":
cmd.extend(["--stdio-ui-test"])
print("cmd: {}".format(" ".join(cmd)))
dispatcher = RPCDispatcher()
dispatcher.register_instance(StdIOHandler(), '')
# line buffered
p = subprocess.Popen(cmd, bufsize=1, universal_newlines=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
rpc_server = RPCServer(
PipeTransport(p.stdout, p.stdin),
JSONRPCProtocol(),
dispatcher
)
rpc_server.serve_forever()
def main(args):
cmd = ["./clef", "--stdio-ui"]
if len(args) > 0 and args[0] == "test":
cmd.extend(["--stdio-ui-test"])
print("cmd: {}".format(" ".join(cmd)))
dispatcher = RPCDispatcher()
dispatcher.register_instance(StdIOHandler(), '')
# line buffered
p = subprocess.Popen(cmd, bufsize=1, universal_newlines=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
rpc_server = RPCServer(
PipeTransport(p.stdout, p.stdin),
JSONRPCProtocol(),
dispatcher
)
rpc_server.serve_forever()
def network_server(statusQueue):
cec_power_control=CecPowerControl(statusQueue)
ctx = zmq.Context()
dispatcher = RPCDispatcher()
transport = ZmqServerTransport.create(ctx, SERVIER_ADDR)
rpc_server = RPCServer(
transport,
JSONRPCProtocol(),
dispatcher
)
dispatcher.register_instance(cec_power_control, 'tv_controller.')
logger.debug("Starting RPC Server")
rpc_server.serve_forever()
def main():
import argparse
parser = argparse.ArgumentParser(description="Wotabag rpi server daemon.")
parser.add_argument('config_file', type=argparse.FileType('r'),
help='YAML configuration file.')
args = parser.parse_args()
# Initialize dbus (this must be done before spawning any threads)
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
dbus.mainloop.glib.threads_init()
bus = dbus.SystemBus()
mainloop = GObject.MainLoop()
with WotabagManager(args.config_file) as wotabag:
logger = logging.getLogger('wotabag')
# Register RPC endpoints
dispatcher = RPCDispatcher()
dispatcher.register_instance(wotabag, 'wotabag.')
# Configure BLE GATT server
sdp_transport = SDPServerTransport(queue_class=gevent.queue.Queue)
ble.advertising_main(mainloop, bus, '')
ble.gatt_server_main(mainloop, bus, '', sdp_transport)
gevent_thread = Thread(target=gevent_main, args=(wotabag, dispatcher, sdp_transport))
try:
# Start gevent (RPC server) thread
gevent_thread.start()
# Run GATT server
logger.info("Running BLE server")
mainloop.run()
except KeyboardInterrupt:
logger.info("Done, cleaning up...")
except Exception as e:
logger.exception(e)
finally:
server_done.set()
mainloop.quit()
logger.info("BLE server finished")
gevent_thread.join()
parser = argparse.ArgumentParser(description="Device service for the Quad temperature controller unit")
parser.add_argument("--device-port","-d",dest="serialPortName",type=str,default="COM5")
parser.add_argument("--baud-rate","-b",dest="baudrate",type=int,default=9600)
parser.add_argument("--service-port","-p",dest="servicePort",type=int,default=5060)
parser.add_argument("--service-ip",dest="serviceIP",type=str,default="127.0.0.1")
parser.add_argument("--fake",dest="fake",type=bool,default=False)
args = parser.parse_args()
system("Title "+ "%sDevice Service: Quad Temperature Controller" % ("" if not args.fake else "FAKE "))
qtc = QuadTemperatureController(args.serialPortName,args.baudrate,fake=args.fake)
dispatcher = RPCDispatcher()
dispatcher.register_instance(qtc)
ctx = zmq.Context()
endpoint = 'tcp://%s:%i' % (args.serviceIP,args.servicePort)
transport = ZmqServerTransport.create(ctx, endpoint)
print "serving requests at %s" % endpoint
rpc_server = RPCServer(
transport,
JSONRPCProtocol(),
dispatcher
)
rpc_server.serve_forever()
parser.add_argument("--baud-rate","-b",dest="baudrate",type=int,default=9600)
parser.add_argument("--service-port","-p",dest="servicePort",type=int,default=5005)
parser.add_argument("--service-ip",dest="serviceIP",type=str,default="127.0.0.1")
args = parser.parse_args()
serial = serial.Serial(port=portNameToInt(args.serialPortName),
baudrate=args.baudrate,
parity=serial.PARITY_NONE,
timeout=0.1)
pirani = KJLC925PiraniSensor(serial,deviceAddress=args.deviceAddress)
dispatcher = RPCDispatcher()
dispatcher.register_instance(pirani)
ctx = zmq.Context()
endpoint = 'tcp://%s:%i' % (args.serviceIP,args.servicePort)
transport = ZmqServerTransport.create(ctx, endpoint)
print "serving requests at %s" % endpoint
rpc_server = RPCServer(
transport,
JSONRPCProtocol(),
dispatcher
)
parser.add_argument("--baud-rate","-b",dest="baudrate",type=int,default=9600)
parser.add_argument("--service-port","-p",dest="servicePort",type=int,default=5050)
parser.add_argument("--service-ip",dest="serviceIP",type=str,default="127.0.0.1")
args = parser.parse_args()
serial = serial.Serial(port=portNameToInt(args.serialPortName),
baudrate=args.baudrate,
parity=serial.PARITY_NONE,
timeout=0.1)
vfc = VFRackUnitController(serial)
dispatcher = RPCDispatcher()
dispatcher.register_instance(vfc)
ctx = zmq.Context()
endpoint = 'tcp://%s:%i' % (args.serviceIP,args.servicePort)
transport = ZmqServerTransport.create(ctx, endpoint)
print "serving requests at %s" % endpoint
rpc_server = RPCServer(
transport,
JSONRPCProtocol(),
dispatcher
)
parser.add_argument("--service-port",
"-p",
dest="servicePort",
type=int,
default=5050)
parser.add_argument("--service-ip",
dest="serviceIP",
type=str,
default="127.0.0.1")
args = parser.parse_args()
serial = serial.Serial(port=portNameToInt(args.serialPortName),
baudrate=args.baudrate,
parity=serial.PARITY_NONE,
timeout=0.1)
vfc = VFRackUnitController(serial)
dispatcher = RPCDispatcher()
dispatcher.register_instance(vfc)
ctx = zmq.Context()
endpoint = 'tcp://%s:%i' % (args.serviceIP, args.servicePort)
transport = ZmqServerTransport.create(ctx, endpoint)
print "serving requests at %s" % endpoint
rpc_server = RPCServer(transport, JSONRPCProtocol(), dispatcher)
rpc_server.serve_forever()
parser.add_argument("--baud-rate","-b",dest="baudrate",type=int,default=9600)
parser.add_argument("--service-port","-p",dest="servicePort",type=int,default=5005)
parser.add_argument("--service-ip",dest="serviceIP",type=str,default="127.0.0.1")
args = parser.parse_args()
serial = serial.Serial(port=portNameToInt(args.serialPortName),
baudrate=args.baudrate,
parity=serial.PARITY_NONE,
timeout=0.1)
tpg = TPG361Controller(serial)
dispatcher = RPCDispatcher()
dispatcher.register_instance(tpg)
ctx = zmq.Context()
endpoint = 'tcp://%s:%i' % (args.serviceIP,args.servicePort)
transport = ZmqServerTransport.create(ctx, endpoint)
print "serving requests at %s" % endpoint
rpc_server = RPCServer(
transport,
JSONRPCProtocol(),
dispatcher
)
if __name__=="__main__":
system("Title "+ "Device Service: Temperature Controller")
parser = argparse.ArgumentParser(description="Temperature controller unit")
parser.add_argument("--modbus-service",dest="modbusService",type=str)
parser.add_argument("--device-id",dest="deviceId",type=str)
parser.add_argument("--service-port","-p",dest="servicePort",type=int,default=5070)
parser.add_argument("--service-ip",dest="serviceIP",type=str,default="127.0.0.1")
args = parser.parse_args()
ctx = zmq.Context()
tcService = TemperatureControllerService(args.modbusService, args.deviceId, ctx)
dispatcher = RPCDispatcher()
dispatcher.register_instance(tcService)
endpoint = 'tcp://%s:%i' % (args.serviceIP,args.servicePort)
transport = ZmqServerTransport.create(ctx, endpoint)
print "serving requests at %s" % endpoint
rpc_server = RPCServer(
transport,
JSONRPCProtocol(),
dispatcher
)
rpc_server.serve_forever()
