def setUp(self):
from gevent import monkey
monkey.patch_all()
self.server = GeventServer(SlaveService, port=18878, auto_register=False)
self.server.logger.quiet = False
self.server._listen()
gevent.spawn(self.server.start)
def setUp(self):
self.server = GeventServer(SlaveService,
port=18878,
auto_register=False)
self.server.logger.quiet = False
self.server._listen()
gevent.spawn(self.server.start)
def start_rpc(self):
self.server = GeventServer(self.service,
hostname=self.options.rpc_host,
port=self.options.rpc_port,
auto_register=False,
logger=logger)
self.server._listen()
gevent.spawn(self.server.start)
return self.server
class Test_GeventServer(unittest.TestCase):
def setUp(self):
from gevent import monkey
monkey.patch_all()
self.server = GeventServer(SlaveService, port=18878, auto_register=False)
self.server.logger.quiet = False
self.server._listen()
gevent.spawn(self.server.start)
def tearDown(self):
self.server.close()
def test_connection(self):
with rpyc.classic.connect("localhost", port=18878) as c:
c.execute("x = 5")
self.assertEqual(c.namespace["x"], 5)
self.assertEqual(c.eval("1+x"), 6)
def test_multiple_connections(self):
def get_ident(gevent):
return gevent.monkey.get_original('threading', 'get_ident')()
c1 = rpyc.classic.connect("localhost", port=18878)
c2 = rpyc.classic.connect("localhost", port=18878)
c3 = rpyc.classic.connect("localhost", port=18878)
with c1, c2, c3:
id0 = get_ident(gevent)
id1 = get_ident(c1.modules.gevent)
id2 = get_ident(c2.modules.gevent)
id3 = get_ident(c3.modules.gevent)
# all server greenlets and clients running in same OS thread ;)
self.assertEqual(id0, id1)
self.assertEqual(id1, id2)
self.assertEqual(id1, id3)
def test_parallelism(self):
conns = [rpyc.classic.connect("localhost", port=18878)
for _ in range(50)]
try:
start = time.time()
gevent.joinall([
gevent.spawn(c.modules.time.sleep, 1)
for c in conns
])
stop = time.time()
self.assertLessEqual(stop - start, 2)
finally:
for c in conns:
c.close()
class Events(object):
rpc_conn = None
def __init__(self, app, options):
self.state = EventsState()
self.options = options
self.app = app
self.server = None
self.service = classpartial(CeleryStateService, self.state)
self.client = RpcClient(self.service)
def get_remote_state(self):
if self.rpc_conn is None:
self.rpc_conn = self.client.connect(self.options.rpc_host,
port=self.options.rpc_port)
return self.rpc_conn.root.get_state()
def start_rpc(self):
self.server = GeventServer(self.service,
hostname=self.options.rpc_host,
port=self.options.rpc_port,
auto_register=False,
logger=logger)
self.server._listen()
gevent.spawn(self.server.start)
return self.server
def run(self):
self.start_rpc()
try_interval = 1
while True:
try:
try_interval *= 2
with self.app.connection() as conn:
recv = EventReceiver(conn,
handlers={"*": self.on_shutter},
app=self.app)
try_interval = 1
recv.capture(limit=None, timeout=None, wakeup=True)
except Exception as e:
logger.error(
"Failed to capture events: '%s', "
"trying again in %s seconds.", e, try_interval)
logger.debug(e, exc_info=True)
time.sleep(try_interval)
def enable_events(self):
# Periodically enable events for workers
# launched after flower
try:
self.app.control.enable_events()
except Exception as e:
logger.debug("Failed to enable events: '%s'", e)
def on_shutter(self, event):
self.state.event(event)
if not self.state.event_count:
# No new events since last snapshot.
return
version = version_reader.version()
#get_h().dispose_component_interface(version_reader) # <-- VersionInfo is always pre-enabled, so don't disable it.
log.info("Controller version: {}".format(version))
except Exception as e:
version = None
log.error("Unable to get controller version: {}".format(e))
# Allow error to pass, so that the server can start below.
# The server will report this error to clients.
global_lock = Semaphore(value=1)
always_enabled_components = []
if version is not None:
if version < (1, 1):
always_enabled_components.append('CarMotors')
component_manager = ComponentManager(global_lock,
always_enabled_components)
ControllerService = classpartial(ControllerService, component_manager,
global_lock, version)
rpc_server = GeventServer(ControllerService, port=18861)
log.info("RUNNING!")
gevent.joinall([
gevent.spawn(rpc_server.start),
#gevent.spawn(component_manager.callback_thread),
])
draw_all()
def exposed_set_battery_percent(self, pct):
"""
`pct` should be an integer in [0, 100].
"""
with self.lock:
if not isinstance(pct, int) or not (0 <= pct <= 100):
raise Exception("Invalid battery percent")
pct = "{}%".format(pct)
global battery_sprite
battery_sprite = header_font.render(pct, True, HEADER_TXT_COLOR)
draw_all()
from rpyc.utils.server import GeventServer
from rpyc.utils.helpers import classpartial
global_lock = Semaphore(value=1)
ConsoleService = classpartial(ConsoleService, global_lock)
rpc_server = GeventServer(ConsoleService, port=18863)
log.info("RUNNING!")
gevent.joinall([
gevent.spawn(rpc_server.start),
])