class RemoteTests(unittest.TestCase): def setUp(self): self.server = ThreadedServer(SlaveService, port=18812, auto_register=False) self.server.logger.quiet = False self.server._start_in_thread() def tearDown(self): while self.server.clients: pass self.server.close() def testConnection(self): conn = rpyc.classic.connect("localhost", port=18812) #print(conn.modules.sys) #print(conn.modules["xml.dom.minidom"].parseString("<a/>")) conn.execute("x = 5") self.assertEqual(conn.namespace["x"], 5) self.assertEqual(conn.eval("1+x"), 6) conn.close() def testHalConnect(self): conn = remote.RPyCModules('localhost') conn.Disconnect() def testHalFind(self): conn = remote.RPyCModules('localhost') try: hal = conn.LoadModule('halc.hal') conn.LoadModule('halc.iproute2') print("") hal.showTree() loInterface = hal.Devices.find('localhost') self.assertIsNotNone(loInterface,'lo Interface expected') finally: conn.Disconnect()
class Test_GDB(unittest.TestCase): def setUp(self): self.dtemp = tempfile.mkdtemp() self.a_out = pathlib.Path(self.dtemp, 'a.out') compile_cmd = ['g++', '-g', '-o', str(self.a_out), '-x', 'c++', '-'] proc = subprocess.Popen(compile_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) proc_input = b'int func(int a, int b){return a + b;}int main(){return func(1, 2);}' stdout, stderr = proc.communicate(input=proc_input) if stdout or stderr: raise ValueError( "stdout and stderr should have be empty for a.out creation") self.server = ThreadedServer(ParentGDB, port=18878, auto_register=False, protocol_config={'allow_all_attrs': True}) self.server._start_in_thread() def tearDown(self): self.server.close() while not self.server._closed: pass def test_gdb(self): parent_gdb_conn = rpyc.connect(host='localhost', port=18878) gdb = parent_gdb_conn.root.get_gdb() gdb.execute('file {}'.format(self.a_out)) disasm = gdb.execute('disassemble main', to_string=True) self.assertIn('End of assembler dump', disasm) parent_gdb_conn.close()
class TestRestricted(unittest.TestCase): def setUp(self): self.server = ThreadedServer(MyService) self.thd = self.server._start_in_thread() self.conn = rpyc.connect("localhost", self.server.port) def tearDown(self): self.conn.close() self.server.close() self.thd.join() def test_restricted(self): obj = self.conn.root.get_one() self.assertEqual(obj.foo(), "foo") self.assertEqual(obj.bar(), "bar") self.assertEqual(obj.__add__("bar"), "foobar") self.assertEqual(obj._privy(), "privy") self.assertEqual(obj.exposed_foobar(), "Fee Fie Foe Foo") self.assertRaises(AttributeError, lambda: obj.spam) def test_restricted2(self): self.server.protocol_config = {'allow_public_attrs': False} obj = self.conn.root.get_one() self.assertEqual(obj.foo(), "foo") self.assertEqual(obj.bar(), "bar") self.assertEqual(obj.__add__("bar"), "foobar") self.assertEqual(obj._privy(), "privy") self.assertRaises(AttributeError, lambda: obj.spam)
class RPyCServer(RPCServerBase): # pragma: no cover """RPyC server support""" def start(self): super(RPyCServer, self).start() import rpyc from rpyc.utils.server import ThreadedServer nm = self class NMService(rpyc.Service): def exposed_call_drop(self, session_id, uid, name, *args): return nm.call_drop(session_id, uid, name, *args) def exposed_get_drop_property(self, session_id, uid, name): return nm.get_drop_attribute(session_id, uid, name) def exposed_has_method(self, session_id, uid, name): return nm.has_method(session_id, uid, name) self._rpycserver = ThreadedServer(NMService, hostname=self._rpc_host, port=self._rpc_port) # ThreadPoolServer # Starts the single-threaded RPyC server for RPC requests self._rpycserverthread = threading.Thread(target=self._rpycserver.start, name="RPyC server") self._rpycserverthread.start() logger.info("Listening for RPC requests via RPyC on %s:%d", self._rpc_host, self._rpc_port) def shutdown(self): super(RPyCServer, self).shutdown() self._rpycserver.close() self._rpycserverthread.join()
class Test_Ssh(unittest.TestCase): def setUp(self): if sys.platform == "win32": self.server = None os.environ["HOME"] = os.path.expanduser("~") self.remote_machine = SshMachine("localhost") else: # assume "ssh localhost" is configured to run without asking for password self.server = ThreadedServer(SlaveService, hostname = "localhost", ipv6 = False, port = 18888, auto_register=False) self.server._start_in_thread() self.remote_machine = SshMachine("localhost") def tearDown(self): if self.server: self.server.close() def test_simple(self): conn = rpyc.classic.ssh_connect(self.remote_machine, 18888) print( "server's pid =", conn.modules.os.getpid()) conn.modules.sys.stdout.write("hello over ssh\n") conn.modules.sys.stdout.flush() def test_connect(self): conn2 = rpyc.ssh_connect(self.remote_machine, 18888, service=MasterService) conn2.modules.sys.stdout.write("hello through rpyc.ssh_connect()\n") conn2.modules.sys.stdout.flush()
def close(self): ThreadedServer.close(self) if self.igd_mapping: try: self.igd.DeletePortMapping(self.port, 'TCP') except Exception as e: self.logger.info('IGD Exception: {}/{}'.format(type(e), e))
class Test_get_id_pack(unittest.TestCase): def setUp(self): self.port = 18878 self.port2 = 18879 self.server = ThreadedServer(SlaveService, port=self.port, auto_register=False) self.server2 = ThreadedServer(SlaveService, port=self.port2, auto_register=False) self.server._start_in_thread() self.server2._start_in_thread() self.conn = rpyc.classic.connect("localhost", port=self.port) self.conn_rpyc = self.conn.root.getmodule('rpyc') self.chained_conn = self.conn_rpyc.connect('localhost', self.port2) def tearDown(self): self.chained_conn.close() self.conn.close() self.server.close() self.server2.close() def test_netref(self): self.assertEquals(self.conn.root.____id_pack__, rpyc.lib.get_id_pack(self.conn.root)) def test_chained_connect(self): self.chained_conn.root.getmodule('os') def test_class_instance_wo_name(self): ss = rpyc.SlaveService() id_pack = rpyc.lib.get_id_pack(ss) self.assertEqual('rpyc.core.service.SlaveService', id_pack[0]) def test_class_wo_name(self): ss = rpyc.SlaveService id_pack = rpyc.lib.get_id_pack(ss) self.assertEqual('rpyc.core.service.SlaveService', id_pack[0])
class IPCServer(threading.Thread): def __init__(self, manager, port=None): super(IPCServer, self).__init__(name='ipc_server') self.daemon = True self.manager = manager self.host = '127.0.0.1' self.port = port or 0 self.password = ''.join(random.choice(string.letters + string.digits) for x in range(15)) self.server = None def authenticator(self, sock): channel = rpyc.Channel(rpyc.SocketStream(sock)) password = channel.recv() if password != self.password: channel.send(AUTH_ERROR) raise rpyc.utils.authenticators.AuthenticationError('Invalid password from client.') channel.send(AUTH_SUCCESS) return sock, self.password def run(self): DaemonService.manager = self.manager self.server = ThreadedServer( DaemonService, hostname=self.host, port=self.port, authenticator=self.authenticator, logger=log ) # If we just chose an open port, write save the chosen one self.port = self.server.listener.getsockname()[1] self.manager.write_lock(ipc_info={'port': self.port, 'password': self.password}) self.server.start() def shutdown(self): self.server.close()
class Test_tlslite(object): def setup(self): authenticator = TlsliteVdbAuthenticator.from_dict(users) self.server = ThreadedServer(rpyc.SlaveService, hostname = "localhost", authenticator = authenticator, auto_register = False) self.server.logger.quiet = True thread.start_new(self.server.start, ()) time.sleep(1) # make sure the server has initialized, etc. def teardown(self): self.server.close() def test_successful(self): c = rpyc.classic.tlslite_connect("localhost", "spam", "eggs", port = self.server.port) print ("server credentials = %r" % (c.root.getconn()._config["credentials"],)) print (c.modules.sys) c.close() def _expect_fail(self, username, password): print ("expecting %s:%s to fail" % (username, password)) c = rpyc.classic.tlslite_connect("localhost", username, password, port = self.server.port) @raises(TLSError) def test_wrong_tokens(self): self._expect_fail("spam", "bar") @raises(TLSError) def test_wrong_tokens2(self): self._expect_fail("bloop", "blaap")
class Test_SSL(object): ''' created key like that http://www.akadia.com/services/ssh_test_certificate.html openssl req -newkey rsa:1024 -nodes -keyout mycert.pem -out mycert.pem ''' def setup(self): self.key = os.path.join( os.path.dirname(__file__) , "server.key") self.cert = os.path.join( os.path.dirname(__file__) , "server.crt") print( self.cert, self.key ) authenticator = SSLAuthenticator(self.key, self.cert) self.server = ThreadedServer(SlaveService, hostname = "localhost",port = 18812, auto_register=False, authenticator = authenticator) self.server.logger.quiet = False t = threading.Thread(target=self.server.start) t.start() def teardown(self): self.server.close() def test_ssl_conenction(self): c = rpyc.classic.ssl_connect("localhost", port = 18812, keyfile=self.key, certfile=self.cert) print( repr(c) ) print( c.modules.sys ) print( c.modules["xml.dom.minidom"].parseString("<a/>") ) c.execute("x = 5") assert c.namespace["x"] == 5 assert c.eval("1+x") == 6 c.close()
def run(id_): port_ = id_ + 18862 server = ThreadedServer(Server, port=port_) try: server.start() except KeyboardInterrupt: server.close()
class Test_Ssh(unittest.TestCase): def setUp(self): # setup an SSH context. on linux this would be as simple as # sshctx = SshContext("myhost") # assuming your user is configured to connect using authorized_keys if sys.platform == "win32": # on my windows box, it's a little more complicated: self.server = None sshctx = SshContext("hollywood.xiv.ibm.com", ssh_program = r"c:\Program Files\Git\bin\ssh.exe", user = "******", keyfile = r"c:\users\sebulba\.ssh\id_rsa") # make sure a classic server is running on remote-host:18888 self.conn = rpyc.classic.ssh_connect(sshctx, "18888") else: # assume "ssh localhost" is configured to run without asking for password self.server = ThreadedServer(SlaveService, hostname = "localhost", ipv6 = False, port = 0, auto_register=False) t = threading.Thread(target=self.server.start) t.setDaemon(True) t.start() time.sleep(0.5) sshctx = SshContext("localhost") self.conn = rpyc.classic.ssh_connect(sshctx, self.server.port) def tearDown(self): self.conn.close() if self.server: self.server.close() def test_simple(self): print( "server's pid =", self.conn.modules.os.getpid()) self.conn.modules.sys.stdout.write("hello over ssh\n") self.conn.modules.sys.stdout.flush()
def __start_service(port: int): while True: server = None try: debug( 'TrackerService.__start_service - Creating instace of service' ) service = TrackerService(3, 160, 3, 1000000) debug( 'TrackerService.__start_service - Creating instace of ThreadedServer' ) server = ThreadedServer( service, port=port, registrar=UDPRegistryClient(), protocol_config={'allow_public_attrs': True}) debug('TrackerService.__start_service - Starting the service') server.start() break except Exception as e: error( 'TrackerService.__start_service - Error starting service, sleeping 5 seconds and trying again' ) error(e) if server is not None: server.close() sleep(0.2)
class Test_ThreadedServer(unittest.TestCase): def setUp(self): self.server = ThreadedServer(SlaveService, port=18878, auto_register=False) self.server.logger.quiet = False self.server._start_in_thread() def tearDown(self): self.server.close() def test_connection(self): conn = rpyc.classic.connect("localhost", port=18878) print(conn.modules.sys) print(conn.modules["xml.dom.minidom"].parseString("<a/>")) conn.execute("x = 5") self.assertEqual(conn.namespace["x"], 5) self.assertEqual(conn.eval("1+x"), 6) conn.close() def test_instancecheck_across_connections(self): conn = rpyc.classic.connect("localhost", port=18878) conn2 = rpyc.classic.connect("localhost", port=18878) conn.execute("import test_magic") conn2.execute("import test_magic") foo = conn.modules.test_magic.Foo() bar = conn.modules.test_magic.Bar() self.assertTrue(isinstance(foo, conn.modules.test_magic.Foo)) self.assertTrue(isinstance(bar, conn2.modules.test_magic.Bar)) self.assertFalse(isinstance(bar, conn.modules.test_magic.Foo)) with self.assertRaises(TypeError): isinstance(conn.modules.test_magic.Foo, bar) conn.close() conn2.close()
class Test_Ssh(unittest.TestCase): def setUp(self): if sys.platform == "win32": self.server = None os.environ["HOME"] = os.path.expanduser("~") self.remote_machine = SshMachine("localhost") else: # assume "ssh localhost" is configured to run without asking for password self.server = ThreadedServer(SlaveService, hostname="localhost", ipv6=False, port=18888, auto_register=False) self.server._start_in_thread() self.remote_machine = SshMachine("localhost") def tearDown(self): if self.server: self.server.close() def test_simple(self): conn = rpyc.classic.ssh_connect(self.remote_machine, 18888) print("server's pid =", conn.modules.os.getpid()) conn.modules.sys.stdout.write("hello over ssh\n") conn.modules.sys.stdout.flush() def test_connect(self): conn2 = rpyc.ssh_connect(self.remote_machine, 18888, service=MasterService) conn2.modules.sys.stdout.write("hello through rpyc.ssh_connect()\n") conn2.modules.sys.stdout.flush()
class Test_SSL(unittest.TestCase): ''' created key like that http://www.akadia.com/services/ssh_test_certificate.html openssl req -newkey rsa:1024 -nodes -keyout mycert.pem -out mycert.pem ''' def setUp(self): self.key = os.path.join( os.path.dirname(__file__) , "server.key") self.cert = os.path.join( os.path.dirname(__file__) , "server.crt") print( self.cert, self.key ) authenticator = SSLAuthenticator(self.key, self.cert) self.server = ThreadedServer(SlaveService, port = 18812, auto_register=False, authenticator = authenticator) self.server.logger.quiet = False self.server._start_in_thread() def tearDown(self): self.server.close() def test_ssl_conenction(self): c = rpyc.classic.ssl_connect("localhost", port = 18812, keyfile=self.key, certfile=self.cert) print( repr(c) ) print( c.modules.sys ) print( c.modules["xml.dom.minidom"].parseString("<a/>") ) c.execute("x = 5") self.assertEqual(c.namespace["x"], 5) self.assertEqual(c.eval("1+x"), 6) c.close()
class RPCserver(Collected,Jobber): """A channel server""" storage = RPCservers def __init__(self,name,host,port): self.name = name self.host=host self.port=port self.server = ThreadedServer(gen_rpcconn(name), hostname=host,port=port,ipv6=True, protocol_config = {"safe_attrs":set(("list","__unicode__","year","month","day","days","date","time","hour","minute","second","seconds","microseconds","ctx","items","iteritems")).union(DEFAULT_CONFIG["safe_attrs"])}) self.server.listener.settimeout(None) self.start_job("job",self._start) super(RPCserver,self).__init__() def _start(self): self.server.start() def delete(self,ctx=None): self.server.close() self.server = None super(RPCserver,self).delete() def list(self): for r in super(RPCserver,self).list(): yield r yield ("host",self.host) yield ("port",self.port) yield ("server",repr(self.server))
def done(server: ThreadedServer): """check the if main server is done""" while True: if not REDUCE_TASK_TO_COM: break else: time.sleep(1) print("MapReduece Task over....") server.close()
class Test_rpyc_over_rpyc(unittest.TestCase): """Issue #346 shows that exceptions are being raised when an RPyC service method calls another RPyC service, forwarding a non-trivial (and thus given as a proxy) argument. """ def setUp(self): self.server = ThreadedServer(Service, port=Service.PORT, auto_register=False) self.i_server = ThreadedServer(Intermediate, port=Intermediate.PORT, auto_register=False, protocol_config=CONNECT_CONFIG) self.server._start_in_thread() self.i_server._start_in_thread() self.conn = rpyc.connect("localhost", port=Intermediate.PORT, config=CONNECT_CONFIG) def tearDown(self): self.conn.close() while self.server.clients or self.i_server.clients: pass self.server.close() self.i_server.close() def test_immutable_object_return(self): """Tests using rpyc over rpyc---issue #346 reported traceback for this use case""" obj = Fee() result = self.conn.root.fee_str(obj) self.assertEqual( str(obj), "Fee", "String representation of obj should not have changed") self.assertEqual( str(result), "Fee", "String representation of result should be the same as obj") def test_return_of_unmodified_parameter(self): obj = Fee() original_obj_id = id(obj) result = self.conn.root.fee(obj) self.assertEqual( str(obj), "Fee", "String representation of obj should not have changed") self.assertEqual( id(result), original_obj_id, "Unboxing of result should be bound to the same object as obj") def test_return_of_modified_parameter(self): obj = Fee() original_obj_id = id(obj) result = self.conn.root.fie_update(obj) self.assertEqual(str(obj), "Fee fie foe foo bar", "String representation of obj should have changed") self.assertEqual( id(result), original_obj_id, "Unboxing of result should be bound to the same object as obj")
def done(server: ThreadedServer): """check the if main server is done""" while True: if not DONE: time.sleep(1) else: TASK_Q.put(None) break print("MapReduece Task over....") server.close()
def close(self): try: ThreadedServer.close(self) except: pass if self.igd_mapping: try: self.igd.DeletePortMapping(self.external_port, 'TCP') except Exception as e: self.logger.info('IGD Exception: %s/%s', type(e), e)
class IPCServer: def __init__(self, manager, port=None): self.daemon = True self.manager = manager self.host = '127.0.0.1' self.port = port or 0 self.password = ''.join( random.choice(string.ascii_letters + string.digits) for x in range(15)) self.server = None self._thread = None def start(self): if not self._thread: self._thread = threading.Thread(name='ipc_server', target=self.run) self._thread.start() def authenticator(self, sock): channel = rpyc.Channel(rpyc.SocketStream(sock)) password = channel.recv().decode('utf-8') if password != self.password: channel.send(AUTH_ERROR) raise rpyc.utils.authenticators.AuthenticationError( 'Invalid password from client.') channel.send(AUTH_SUCCESS) return sock, self.password def run(self): # Make the rpyc logger a bit quieter when we aren't in debugging. rpyc_logger = logging.getLogger('ipc.rpyc') if logger.level( self.manager.options.loglevel).no > logger.level('DEBUG').no: rpyc_logger.setLevel(logging.WARNING) DaemonService.manager = self.manager self.server = ThreadedServer( DaemonService, hostname=self.host, port=self.port, authenticator=self.authenticator, logger=rpyc_logger, # Timeout can happen when piping to 'less' and delaying scrolling to bottom. Make it a long timeout. protocol_config={'sync_request_timeout': 3600}, ) # If we just chose an open port, write save the chosen one self.port = self.server.listener.getsockname()[1] self.manager.write_lock(ipc_info={ 'port': self.port, 'password': self.password }) self.server.start() def shutdown(self): if self.server: self.server.close()
class BBTestWinService(object): """A container for an RPyC server serving our bbtest RPyC logic""" HOSTNAME = "0.0.0.0" SERVER_LOG_DIR = "C:\\Users\\bbtest\\logs" SERVER_LOG_FILENAME = "BBTest_server_service.log" FALLBACK_LOG_DIR = "C:\\Temp" def __init__(self): """The server of the underlying rpyc package""" self._rpyc_server = None def start_rpyc_server(self): self._init_logger() self._rpyc_server = ThreadedServer(BBTestService, hostname=self.HOSTNAME, port=DEFAULT_RPYC_SERVER_PORT, logger=self.logger) self._rpyc_server.start() def stop_rpyc_server(self): self._rpyc_server.close() # TODO: why sleep? why 2? time.sleep(2) def _init_logger(self): self._init_logger_dir() handler = logging.FileHandler(os.path.join(self.log_dir, self.SERVER_LOG_FILENAME), mode="w+") handler.setFormatter( logging.Formatter( fmt='%(asctime)s - %(levelname)s - %(module)s - %(message)s')) self.logger = logging.Logger("Bbtest_server", level=logging.DEBUG) self.logger.addHandler(handler) def _init_logger_dir(self): """Create log directory if needed. In case of failure, fall back to an always-present directory """ if os.path.isdir(self.SERVER_LOG_DIR): self.log_dir = self.SERVER_LOG_DIR else: try: os.makedirs(self.SERVER_LOG_DIR) self.log_dir = self.SERVER_LOG_DIR except (IOError, WindowsError) as e: print(e) print( "Server log dir does not exist and could not be created, falling back to %s" % self.FALLBACK_LOG_DIR) self.log_dir = self.FALLBACK_LOG_DIR
class Test_Netref_Hierarchy(unittest.TestCase): def setUp(self): self.server = ThreadedServer(SlaveService, port=18878, auto_register=False) self.server.logger.quiet = False self.server._start_in_thread() def tearDown(self): self.server.close() def test_instancecheck_across_connections(self): conn = rpyc.classic.connect('localhost', port=18878) conn2 = rpyc.classic.connect('localhost', port=18878) conn.execute('import test_magic') conn2.execute('import test_magic') foo = conn.modules.test_magic.Foo() bar = conn.modules.test_magic.Bar() self.assertTrue(isinstance(foo, conn.modules.test_magic.Foo)) self.assertTrue(isinstance(bar, conn2.modules.test_magic.Bar)) self.assertFalse(isinstance(bar, conn.modules.test_magic.Foo)) with self.assertRaises(TypeError): isinstance(conn.modules.test_magic.Foo, bar) conn.close() conn2.close() def test_classic(self): conn = rpyc.classic.connect_thread() x = conn.builtin.list((1, 2, 3, 4)) print(conn.builtin.list, type(conn.builtin.list)) print(x, type(x)) print(x.__class__, type(x.__class__)) self.assertTrue(isinstance(x, list)) self.assertTrue(isinstance(x, rpyc.BaseNetref)) with self.assertRaises(TypeError): isinstance([], x) i = 0 self.assertTrue(type(x).__getitem__(x, i) == x.__getitem__(i)) _builtins = conn.modules.builtins if rpyc.lib.compat.is_py3k else conn.modules.__builtin__ self.assertEqual(repr(_builtins.float.__class__), repr(type)) self.assertEqual(repr(type(_builtins.float)), repr(type(_builtins.type))) def test_instancecheck_list(self): service = MyService() conn = rpyc.connect_thread(remote_service=service) conn.root remote_list = conn.root.getlist() self.assertTrue(conn.root.instance(remote_list, list)) conn.close()
class ServiceThread(threading.Thread): ''' Control server main execution thread. Note: ThreadedServer launches a new thread for every connection. ''' def __init__(self, port): threading.Thread.__init__(self) self.port = port def setController(self, ctrl): ''' Set the controller object for the service thread. ''' global theController theController = ctrl def run(self): ''' Runs the rpyc ThreadedServer with the service implementation. NOTE: it expects a rpyc service registry running ''' global theController host = theController.hostAddress self.auth = SSLAuthenticator( theController.keyFile, theController.certFile, cert_reqs=ssl.CERT_REQUIRED, ca_certs=theController.certFile, ) if Config.SECURITY else None try: self.server = ThreadedServer( ControllerService, hostname=host, port=self.port, authenticator=self.auth, auto_register=True, protocol_config={"allow_public_attrs": True}) except: print("Failed to create server") traceback.print_exc() os._exit(0) self.server.start() time.sleep(0.010) def stop(self): ''' Terminates the service. Called when the program exits. ''' ControllerService.STOPPING = True self.server.close()
class RPyCWorker(): """RPyC worker class.""" def __init__(self, *args, port=18861, **kwargs): self.server = ThreadedServer(ModNASService, *args, port=port, **kwargs) def run(self, estim): """Run worker.""" self.server.service.estim = estim self.server.service.server = self.server self.server.start() def close(self): """Close worker.""" self.server.close()
class MasterRPC: def __init__(self, redis_host, redis_port=6379, slaves_db=3, port=8780, auto_register=False): global slaves, ws slaves = SlaveStorage(slaves_db, redis_host, redis_port) ws = websocket.create_connection("ws://localhost:8000/soc") self.server = ThreadedServer(MasterRPCService, port=port, auto_register=auto_register) logging.info("Start master on port %d..." % port) ws.send("Start master on port %d..." % port) # http.post("Start master on port %d..." % port) self.server.start() def close(self): self.server.close()
class ServiceThread(threading.Thread): ''' Control server main execution thread. Note: ThreadedServer launches a new thread for every connection. ''' def __init__(self, drunner, host, port, registry_ip): threading.Thread.__init__(self) global theAgent theAgent = drunner self.host = host self.port = port self.registry_ip = registry_ip def run(self): ''' Runs the rpyc ThreadedServer with the service implementation. NOTE: it expects a rpyc service registry running ''' # self.auth = SSLAuthenticator(keyFile, certFile, # cert_reqs=ssl.CERT_REQUIRED, ca_certs=theAgent.certFile, # ) if Config.SECURITY else None if self.host == "": self.host = getHostIP() registrar_obj = None if self.registry_ip is not None: logger_obj = logger = logging.getLogger("%s/%s" % ("RIAPS_DSSA", self.port)) registrar_obj = UDPRegistryClient(ip=self.registry_ip, logger=logger_obj) self.server = ThreadedServer( Service, hostname=self.host, port=self.port, # authenticator = self.auth, registrar=registrar_obj, auto_register=True, protocol_config={"allow_public_attrs": True}) self.server.start() time.sleep(0.010) def stop(self): ''' Terminates the service. Called when the program exits. ''' Service.STOPPING = True self.server.close()
class TestRestricted(unittest.TestCase): def setUp(self): self.server = ThreadedServer(MyService, port=0) self.thd = self.server._start_in_thread() self.conn = rpyc.connect("localhost", self.server.port) def tearDown(self): self.conn.close() self.server.close() self.thd.join() def test_restricted(self): obj = self.conn.root.get_one() self.assertEqual(obj.foo(), "foo") self.assertEqual(obj.bar(), "bar") self.assertRaises(AttributeError, lambda: obj.spam)
class TestRestricted(unittest.TestCase): def setUp(self): self.server = ThreadedServer(MyService, port = 0) self.thd = self.server._start_in_thread() self.conn = rpyc.connect("localhost", self.server.port) def tearDown(self): self.conn.close() self.server.close() self.thd.join() def test_restricted(self): obj = self.conn.root.get_one() self.assertEqual(obj.foo(), "foo") self.assertEqual(obj.bar(), "bar") self.assertRaises(AttributeError, lambda: obj.spam)
class IPCServer(threading.Thread): def __init__(self, manager, port=None): super(IPCServer, self).__init__(name='ipc_server') self.daemon = True self.manager = manager self.host = '127.0.0.1' self.port = port or 0 self.password = ''.join( random.choice(string.ascii_letters + string.digits) for x in range(15)) self.server = None def authenticator(self, sock): channel = rpyc.Channel(rpyc.SocketStream(sock)) password = channel.recv().decode('utf-8') if password != self.password: channel.send(AUTH_ERROR) raise rpyc.utils.authenticators.AuthenticationError( 'Invalid password from client.') channel.send(AUTH_SUCCESS) return sock, self.password def run(self): # Make the rpyc logger a bit quieter when we aren't in debugging. rpyc_logger = logging.getLogger('ipc.rpyc') if logging.getLogger().getEffectiveLevel() > logging.DEBUG: rpyc_logger.setLevel(logging.WARNING) DaemonService.manager = self.manager self.server = ThreadedServer( DaemonService, hostname=self.host, port=self.port, authenticator=self.authenticator, logger=rpyc_logger, ) # If we just chose an open port, write save the chosen one self.port = self.server.listener.getsockname()[1] self.manager.write_lock(ipc_info={ 'port': self.port, 'password': self.password }) self.server.start() def shutdown(self): if self.server: self.server.close()
class Test_ThreadedServer(unittest.TestCase): def setUp(self): self.server = ThreadedServer(SlaveService, port=18878, auto_register=False) self.server.logger.quiet = False self.server._start_in_thread() def tearDown(self): self.server.close() def test_connection(self): c = rpyc.classic.connect("localhost", port=18878) print( c.modules.sys ) print( c.modules["xml.dom.minidom"].parseString("<a/>") ) c.execute("x = 5") self.assertEqual(c.namespace["x"], 5) self.assertEqual(c.eval("1+x"), 6) c.close()
class Test_IPv6(unittest.TestCase): def setUp(self): self.server = ThreadedServer(SlaveService, port=0, ipv6=True) self.server.logger.quiet = True self.thd = self.server._start_in_thread() def tearDown(self): self.server.close() self.thd.join() def test_ipv6_conenction(self): c = rpyc.classic.connect("::1", port=self.server.port, ipv6=True) print(repr(c)) print(c.modules.sys) print(c.modules["xml.dom.minidom"].parseString("<a/>")) c.execute("x = 5") self.assertEqual(c.namespace["x"], 5) self.assertEqual(c.eval("1+x"), 6) c.close()
class RemoteServer(AbstractExtension): """Server for remote connections that provides messagebus functionality to users outside of Zaf.""" def __init__(self, config, instances): self._enabled = config.get(REMOTE_ENABLED) self._port = config.get(REMOTE_PORT) self.server = None self.thread = None def is_running(self): return self.server and self.thread and self.thread.is_alive() def register_dispatchers(self, messagebus): if self._enabled: self.server = ThreadedServer( create_service(messagebus), port=self._port, reuse_addr=True, protocol_config={'allow_all_attrs': True}, logger=logger) self.thread = Thread(target=self.server.start) self.thread.start() @callback_dispatcher([AFTER_COMMAND], [APPLICATION_ENDPOINT]) def close_server(self, message=None): self.destroy() def destroy(self): try: if self.is_running(): logger.debug('Stopping remote server') if len(self.server.clients) > 0: # If all clients haven't been closed yet we will wait for a short time # This can happen in systests because the close of zzaf is too quick for # a clean disconnect logger.debug( 'Clients still connected. Waiting 0.1 seconds before hard close of remote server' ) time.sleep(0.1) self.server.close() self.thread.join() finally: self._after_command_dispatcher = None
class Test_IPv6(unittest.TestCase): def setUp(self): self.server = ThreadedServer(SlaveService, port = 0, ipv6 = True) self.server.logger.quiet = True self.thd = self.server._start_in_thread() def tearDown(self): self.server.close() self.thd.join() def test_ipv6_conenction(self): c = rpyc.classic.connect("::1", port = self.server.port, ipv6 = True) print( repr(c) ) print( c.modules.sys ) print( c.modules["xml.dom.minidom"].parseString("<a/>") ) c.execute("x = 5") self.assertEqual(c.namespace["x"], 5) self.assertEqual(c.eval("1+x"), 6) c.close()
class Test_ThreadedServer(object): def setup(self): self.server = ThreadedServer(SlaveService, hostname = "localhost", port=18874, auto_register=False) self.server.logger.quiet = False t = threading.Thread(target=self.server.start) t.start() def teardown(self): self.server.close() def test_conenction(self): c = rpyc.classic.connect("localhost", port=18874) print( c.modules.sys ) print( c.modules["xml.dom.minidom"].parseString("<a/>") ) c.execute("x = 5") assert c.namespace["x"] == 5 assert c.eval("1+x") == 6 c.close()
def main(): os.chdir('/tmp/') t = ThreadedServer(WorkerService, hostname="localhost", port=0, reuse_addr=True) thd = Thread(target=t.start) thd.daemon = True thd.start() sys.stdout.write("%s\n" % (t.port, )) sys.stdout.flush() try: sys.stdin.read() finally: t.close() thd.join()
class IPCServer(threading.Thread): def __init__(self, manager, port=None): super(IPCServer, self).__init__(name='ipc_server') self.daemon = True self.manager = manager self.host = '127.0.0.1' self.port = port or 0 self.password = ''.join( random.choice(string.ascii_letters + string.digits) for x in range(15) ) self.server = None def authenticator(self, sock): channel = rpyc.Channel(rpyc.SocketStream(sock)) password = channel.recv().decode('utf-8') if password != self.password: channel.send(AUTH_ERROR) raise rpyc.utils.authenticators.AuthenticationError('Invalid password from client.') channel.send(AUTH_SUCCESS) return sock, self.password def run(self): # Make the rpyc logger a bit quieter when we aren't in debugging. rpyc_logger = logging.getLogger('ipc.rpyc') if logging.getLogger().getEffectiveLevel() > logging.DEBUG: rpyc_logger.setLevel(logging.WARNING) DaemonService.manager = self.manager self.server = ThreadedServer( DaemonService, hostname=self.host, port=self.port, authenticator=self.authenticator, logger=rpyc_logger, ) # If we just chose an open port, write save the chosen one self.port = self.server.listener.getsockname()[1] self.manager.write_lock(ipc_info={'port': self.port, 'password': self.password}) self.server.start() def shutdown(self): if self.server: self.server.close()
class RPyCViewerLevelThread(ViewerLevelThread): """ implementation of viewer level thread using Remote Python Calls (RPyC) """ def __init__(self, *args, **kwargs): ViewerLevelThread.__init__(self, *args, **kwargs) def run(self): """ instantiate the server """ if self.verbose: print 'thread started...' global RPYCTHREAD RPYCTHREAD = self self.server = ThreadedServer(RPyCViewerService, port=DEFAULT_SERVER_PORT, auto_register=False, registrar=UDPRegistryClient()) self.server.start() def join(self): self.server.close() ViewerLevelThread.join(self)
class RPyCViewerLevelThread(ViewerLevelThread): """ implementation of viewer level thread using Remote Python Calls (RPyC) """ def __init__(self, *args, **kwargs): ViewerLevelThread.__init__(self, *args, **kwargs) def run(self): """ instantiate the server """ if self.verbose: print "thread started..." global RPYCTHREAD RPYCTHREAD = self self.server = ThreadedServer( RPyCViewerService, port=DEFAULT_SERVER_PORT, auto_register=False, registrar=UDPRegistryClient() ) self.server.start() def join(self): self.server.close() ViewerLevelThread.join(self)
class Test_IPv6(object): def setup(self): self.server = ThreadedServer(SlaveService, port = 0, ipv6 = True) self.server.logger.quiet = True self.thd = threading.Thread(target = self.server.start) self.thd.start() def teardown(self): self.server.close() self.thd.join() def test_ipv6_conenction(self): c = rpyc.classic.connect("::1", port = self.server.port, ipv6 = True) print( repr(c) ) print( c.modules.sys ) print( c.modules["xml.dom.minidom"].parseString("<a/>") ) c.execute("x = 5") assert c.namespace["x"] == 5 assert c.eval("1+x") == 6 c.close()
class Test_ThreadedServerOverUnixSocket(unittest.TestCase): def setUp(self): self.socket_path = tempfile.mktemp() self.server = ThreadedServer(SlaveService, socket_path=self.socket_path, auto_register=False) self.server.logger.quiet = False self.server._start_in_thread() def tearDown(self): self.server.close() os.remove(self.socket_path) def test_connection(self): c = rpyc.classic.unix_connect(self.socket_path) print( c.modules.sys ) print( c.modules["xml.dom.minidom"].parseString("<a/>") ) c.execute("x = 5") self.assertEqual(c.namespace["x"], 5) self.assertEqual(c.eval("1+x"), 6) c.close()
class Test_Restricted(object): def setup(self): self.server = ThreadedServer(MyService, port = 0) self.thd = Thread(target = self.server.start) self.thd.start() self.conn = rpyc.connect("localhost", self.server.port) def teardown(self): self.conn.close() self.server.close() self.thd.join() def test_restricted(self): obj = self.conn.root.get_one() assert obj.foo() == "foo" assert obj.bar() == "bar" try: obj.spam() except AttributeError: pass else: assert False, "expected an attribute error!"
class ComThread(threading.Thread): """ Class to run the rpyc server thread ComServer will handle execution of commands from the web UI or other controllers. It allows the client (mycodo_client.py, excuted as non-root user) to communicate with the daemon (mycodo_daemon.py, executed as root). """ def __init__(self, mycodo): threading.Thread.__init__(self) self.logger = logging.getLogger("mycodo.rpyc") self.logger.setLevel(logging.WARNING) self.mycodo = mycodo self.server = None self.rpyc_monitor = None def run(self): try: # Start RPYC server service = mycodo_service(self.mycodo) self.server = ThreadedServer(service, port=18813, logger=self.logger) self.server.start() # self.rpyc_monitor = threading.Thread( # target=monitor_rpyc, # args=(self.logger,)) # self.rpyc_monitor.daemon = True # self.rpyc_monitor.start() except Exception as err: self.logger.exception( "ERROR: ComThread: {msg}".format(msg=err)) def close(self): self.server.close()
gConsole = curses.initscr() # Create the RPC server and error handler pServer = ThreadedServer(StateMonitorService, port = 18861, logger = log) # Start the RPC server thread pStateMonitorThread = StateMonitorThread.StateMonitorThread() pStateMonitorThread.SetParameters(pServer) pStateMonitorThread.start() # Clear the screen and notify the user that we are waiting for the CLI to connect ClearScreen() Print("Elixys state monitoring system") Print("Waiting for the server to connect (press 'q' to quit)...") # Run the server until the user presses 'q' to quit while not Utilities.CheckForQuit(): time.sleep(0.25) # Stop the RPC server pServer.close() pStateMonitorThread.join() # Clean up the console on Linux if gOS == "Linux": gConsole = curses.endwin() # Say goodbye print "Complete"
connections.root.save_data(123) print connections.root.get_data() if __name__ == '__main__': import threading import time server = ThreadedServer(MyService, port=15111) client = MyClient() def start(): print '*************************************' print '*************************************' print '*****************RpyC****************' print '************ **************' print '*************************************' print '***************start server**********' print '*************************************' print '*************************************\n\n' server.start() threading.Thread(target=start).start() client.conn() time.sleep(5) server.close() print 'service stop.'