def __init__(self, rest_url=None):
self.dispatcher = RESTDispatcher(rest_url)
# TinyRPC WSGI App
self.transport = WsgiServerTransport(queue_class=gevent.queue.Queue)
self.wsgi_app = self.transport.handle
# TinyRPC RPC Server
self.rpc_server = RPCServerGreenlets(self.transport, JSONRPCProtocol(),
self.dispatcher)
gevent.spawn(self.rpc_server.serve_forever)
def __init__(self, app):
log.debug('initializing JSONRPCServer')
BaseService.__init__(self, app)
self.app = app
self.dispatcher = RPCDispatcher()
transport = WsgiServerTransport(queue_class=gevent.queue.Queue)
# start wsgi server as a background-greenlet
self.wsgi_server = gevent.wsgi.WSGIServer(('127.0.0.1', 5000),
transport.handle)
self.rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(),
self.dispatcher)
def wsgi_server(request):
app = WsgiServerTransport(queue_class=gevent.queue.Queue)
server = WSGIServer(TEST_SERVER_ADDR, app.handle)
def fin():
server.stop()
server_greenlet.join()
request.addfinalizer(fin)
server_greenlet = gevent.spawn(server.serve_forever)
gevent.sleep(0) # wait for server to come up
return (app, 'http://%s:%d' % TEST_SERVER_ADDR)
def nsRPCBringupServer(ns, path, host, port, maxconn):
name = os.path.basename(path)
dev_path = '/dev/rpc/{}'.format(name)
if nsRPCisServer(ns, path) is not True:
nsError(ns, "RPC service {} misconfigured".format(name))
return False
nsInfo(ns, "Configuring RPC server from {}".format(path))
nsMkdir(ns, dev_path)
nsMkdir(ns, "{}/root".format(dev_path))
_to_root = nsGet(ns, "{}/jail".format(path), [])
for j in _to_root:
_n = os.path.basename(j)
_dst = "{}/root/{}".format(dev_path, _n)
nsInfo(ns, "RPC.JAIL({}): {}".format(name, j))
nsLn(ns, j, _dst)
dispatcher = RPCDispatcher()
nsSet(ns, "{}/dispatcher".format(dev_path), dispatcher)
for h in nsLs(ns, "{}/handlers".format(path)):
nsInfo(ns, "Registering {}->{} ".format(name, h))
_fun = nsGet(ns, "{}/handlers/{}".format(path, h))
dispatcher.add_method(partial(_fun, dev_path), h)
transport = WsgiServerTransport(queue_class=gevent.queue.Queue)
nsSet(ns, "{}/transport".format(dev_path), transport)
nsSet(ns, "{}/listen".format(dev_path), host)
nsSet(ns, "{}/port".format(dev_path), host)
nsConsole(
ns, "RPC server {} will be listening on tcp://{}:{}".format(
name, host, port))
pool = gevent.pool.Pool(maxconn)
nsSet(ns, "{}/pool".format(dev_path), pool)
wsgi_server = gevent.pywsgi.WSGIServer((host, port),
transport.handle,
spawn=pool,
log=None)
nsSet(ns, "{}/wsgi".format(dev_path), wsgi_server)
nsDaemon(ns, "{}:WSGI".format(name), wsgi_server.serve_forever, _raw=True)
rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(), dispatcher)
if nsGet(ns, "/config/RPCCatchCalls") is True or nsGet(
ns, "/etc/flags/rpctrace", False) is True:
_q = gevent.queue.Queue()
nsSet(ns, "{}/trace".format(dev_path), _q)
rpc_server.trace = partial(nsRPCCatcher, ns, dev_path, _q)
nsSet(ns, "{}/rpc", rpc_server)
nsDaemon(ns, "{}:RPC".format(name), rpc_server.serve_forever, _raw=True)
nsInfo(ns, "RPC server {} is up".format(name))
return True
def __init__(self, interface):
"""
Args:
interface: Interface to provide.
"""
self.__dispatcher = RPCLoggingDispatcher()
transport = WsgiServerTransport(queue_class=gevent.queue.Queue)
self._wsgi_server = gevent.wsgi.WSGIServer(
('', configuration.get_rpc_server_port()),
transport.handle,
log=None)
gevent.spawn(self._wsgi_server.serve_forever)
self.__server = RPCServerGreenlets(transport, JSONRPCProtocol(),
self.__dispatcher)
# register interface's public functions
self.__dispatcher.register_instance(interface, "")
def __init__(self, app):
log.debug('initializing JSONRPCServer')
BaseService.__init__(self, app)
self.app = app
self.dispatcher = LoggingDispatcher()
# register sub dispatchers
for subdispatcher in self.subdispatcher_classes():
subdispatcher.register(self)
transport = WsgiServerTransport(queue_class=gevent.queue.Queue)
# start wsgi server as a background-greenlet
self.listen_port = app.config['jsonrpc']['listen_port']
self.listen_host = app.config['jsonrpc']['listen_host']
self.wsgi_server = gevent.wsgi.WSGIServer(
(self.listen_host, self.listen_port),
transport.handle,
log=WSGIServerLogger)
self.rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(),
self.dispatcher)
self.default_block = 'latest'
def gevent_main(wotabag, dispatcher, sdp_transport):
"""Secondary thread for gevent event loop.
Needed so that it does not conflict with dbus/glib event loop.
"""
logger = logging.getLogger('wotabag')
ble_rpc_server = WotabagRPCServerGreenlets(
sdp_transport,
JSONRPCProtocol(),
dispatcher
)
# Configure WSGI (HTTP) RPC server
wsgi_transport = WsgiServerTransport(queue_class=gevent.queue.Queue)
wsgi_server = WSGIServer((wotabag.rpc_host, wotabag.rpc_port), wsgi_transport.handle)
gevent.spawn(wsgi_server.serve_forever)
wsgi_rpc_server = WotabagRPCServerGreenlets(
wsgi_transport,
JSONRPCProtocol(),
dispatcher
)
try:
greenlets = []
logger.info("Running RPC server at {}:{}".format(wotabag.rpc_host, wotabag.rpc_port))
greenlets.append(wsgi_rpc_server.start())
greenlets.append(ble_rpc_server.start())
gevent.sleep(0)
server_done.wait()
except Exception as e:
logger.exception(e)
raise e
finally:
gevent.joinall(greenlets)
logger.info("RPC server finished")
import gevent
import gevent.pywsgi
import gevent.queue
from tinyrpc.protocols.jsonrpc import JSONRPCProtocol
from tinyrpc.transports.wsgi import WsgiServerTransport
from tinyrpc.server.gevent import RPCServerGreenlets
from tinyrpc.dispatch import RPCDispatcher
import subprocess
import json
import radio_data_rate
import time
import re
dispatcher = RPCDispatcher()
transport = WsgiServerTransport(queue_class=gevent.queue.Queue)
# start wsgi server as a background-greenlet
wsgi_server = gevent.pywsgi.WSGIServer(('192.168.1.100', 8080),
transport.handle)
gevent.spawn(wsgi_server.serve_forever)
rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(), dispatcher)
current_radio_rate_r1 = {'vhf': 9600, 'uhf': 240, 'sat_comm': 512}
def set_vhf_data_rate(interface=None, rate=None, parent=None, classid=None):
if None not in (interface, rate, parent, classid):
if rate == 9600:
rate_in_kbps = '9.6kbps'
elif rate == 4800:
from UE_ROS_Bridge_ListenerBase import SetupListeners, SetupServiceListeners
from UE_ROS_Bridge_PublisherBase import SetupPublishers
from timeit import default_timer as timer
import gevent
import gevent.wsgi
import gevent.queue
from tinyrpc.protocols.jsonrpc import JSONRPCProtocol
from tinyrpc.transports.wsgi import WsgiServerTransport
from tinyrpc.server.gevent import RPCServerGreenlets
from tinyrpc.dispatch import RPCDispatcher
from threading import Lock
dispatcher = RPCDispatcher()
transport = WsgiServerTransport(max_content_length=4096 * 1024,
queue_class=gevent.queue.Queue)
# start wsgi server as a background-greenlet
wsgi_server = gevent.wsgi.WSGIServer(('0.0.0.0', 10090), transport.handle)
gevent.spawn(wsgi_server.serve_forever)
rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(), dispatcher)
TFPublisher = rospy.Publisher('tf', tfMessage, queue_size=1)
rospy.init_node('UE_ROS_Bridge')
tfBroadcaster = tf.TransformBroadcaster()
serviceHandlers = {}
messagePages = [{}, {}]
messageSendingPage = [0]
pageMutex = Lock()