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()
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_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 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_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_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_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.'
