def discover(service_name, host=None, registrar=None, timeout=2):
"""
discovers hosts running the given service
:param service_name: the service to look for
:param host: limit the discovery to the given host only (None means any host)
:param registrar: use this registry client to discover services. if None,
use the default UDPRegistryClient with the default settings.
:param timeout: the number of seconds to wait for a reply from the registry
if no hosts are found, raises DiscoveryError
:raises: ``DiscoveryError`` if no server is found
:returns: a list of (ip, port) pairs
"""
if registrar is None:
registrar = UDPRegistryClient(timeout=timeout)
addrs = registrar.discover(service_name)
if not addrs:
raise DiscoveryError("no servers exposing %r were found" % (service_name,))
if host:
ips = socket.gethostbyname_ex(host)[2]
addrs = [(h, p) for h, p in addrs if h in ips]
if not addrs:
raise DiscoveryError("no servers exposing %r were found on %r" % (service_name, host))
return addrs
def discover(service_name, host = None, registrar = None, timeout = 2):
"""
discovers hosts running the given service
:param service_name: the service to look for
:param host: limit the discovery to the given host only (None means any host)
:param registrar: use this registry client to discover services. if None,
use the default UDPRegistryClient with the default settings.
:param timeout: the number of seconds to wait for a reply from the registry
if no hosts are found, raises DiscoveryError
:raises: ``DiscoveryError`` if no server is found
:returns: a list of (ip, port) pairs
"""
if registrar is None:
registrar = UDPRegistryClient(timeout = timeout)
addrs = registrar.discover(service_name)
if not addrs:
raise DiscoveryError("no servers exposing %r were found" % (service_name,))
if host:
ips = socket.gethostbyname_ex(host)[2]
addrs = [(h, p) for h, p in addrs if h in ips]
if not addrs:
raise DiscoveryError("no servers exposing %r were found on %r" % (service_name, host))
return addrs
def list_services(registrar=None, timeout=2):
services = ()
if registrar is None:
registrar = UDPRegistryClient(timeout=timeout)
services = registrar.list()
if services is None:
raise ForbiddenError("Registry doesn't allow listing")
return services
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 main(self):
if self.registry_type == "UDP":
if self.registry_host is None:
self.registry_host = "255.255.255.255"
self.registrar = UDPRegistryClient(ip = self.registry_host, port = self.registry_port)
else:
if self.registry_host is None:
raise ValueError("With TCP registry, you must specify --registry-host")
self.registrar = TCPRegistryClient(ip = self.registry_host, port = self.registry_port)
if self.ssl_keyfile:
self.authenticator = SSLAuthenticator(self.ssl_keyfile, self.ssl_certfile,
self.ssl_cafile)
default_port = DEFAULT_SERVER_SSL_PORT
else:
self.authenticator = None
default_port = DEFAULT_SERVER_PORT
if self.port is None:
self.port = default_port
setup_logger(self.quiet, self.logfile)
if self.mode == "threaded":
factory = ThreadedServer
elif self.mode == "forking":
factory = ForkingServer
elif self.mode == "stdio":
self._serve_stdio()
return
t = factory(SlaveService, hostname = self.host, port = self.port,
reuse_addr = True, ipv6 = self.ipv6, authenticator = self.authenticator,
registrar = self.registrar, auto_register = self.auto_register)
t.start()
def getOptions():
"""Parses options for our various servers."""
options, args = PARSER.parse_args()
if args:
PARSER.error("does not take positional arguments: %r" % (args, ))
options.mode = options.mode.lower()
if options.regtype.lower() == "udp":
if options.reghost is None:
options.reghost = "255.255.255.255"
options.registrar = UDPRegistryClient(ip=options.reghost,
port=options.regport)
elif options.regtype.lower() == "tcp":
if options.reghost is None:
PARSER.error("must specific --registry-host")
options.registrar = TCPRegistryClient(ip=options.reghost,
port=options.regport)
else:
PARSER.error("invalid registry type %r" % (options.regtype, ))
if options.vdbfile:
if not os.path.exists(options.vdbfile):
PARSER.error("vdb file does not exist")
options.authenticator = VdbAuthenticator.from_file(options.vdbfile,
mode="r")
else:
options.authenticator = None
mode = options.mode
options.handler = "serve%s" % (mode[0].upper() + mode[1:], )
if options.handler not in globals():
PARSER.error("invalid mode %r" % (options.mode, ))
return options
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)
def main(self):
if not self.host:
self.host = "::1" if self.ipv6 else "127.0.0.1"
if self.registry_type == "UDP":
if self.registry_host is None:
self.registry_host = "255.255.255.255"
self.registrar = UDPRegistryClient(ip=self.registry_host, port=self.registry_port)
else:
if self.registry_host is None:
raise ValueError("With TCP registry, you must specify --registry-host")
self.registrar = TCPRegistryClient(ip=self.registry_host, port=self.registry_port)
if self.ssl_keyfile:
self.authenticator = SSLAuthenticator(self.ssl_keyfile, self.ssl_certfile,
self.ssl_cafile)
default_port = DEFAULT_SERVER_SSL_PORT
else:
self.authenticator = None
default_port = DEFAULT_SERVER_PORT
if self.port is None:
self.port = default_port
setup_logger(self.quiet, self.logfile)
if self.mode == "threaded":
self._serve_mode(ThreadedServer)
elif self.mode == "forking":
self._serve_mode(ForkingServer)
elif self.mode == "oneshot":
self._serve_oneshot()
elif self.mode == "stdio":
self._serve_stdio()
def get_options():
options, args = parser.parse_args()
if args:
parser.error("does not take positional arguments: %r" % (args, ))
options.mode = options.mode.lower()
if options.regtype.lower() == "udp":
if options.reghost is None:
options.reghost = "255.255.255.255"
options.registrar = UDPRegistryClient(ip=options.reghost,
port=options.regport)
elif options.regtype.lower() == "tcp":
if options.reghost is None:
parser.error("must specific --registry-host")
options.registrar = TCPRegistryClient(ip=options.reghost,
port=options.regport)
else:
parse.error("invalid registry type %r" % (options.regtype, ))
if options.vdbfile:
if not os.path.exists(options.vdbfile):
parser.error("vdb file does not exist")
options.authenticator = VdbAuthenticator.from_file(options.vdbfile,
mode="r")
else:
options.authenticator = None
options.handler = "serve_%s" % (options.mode, )
if options.handler not in globals():
parser.error("invalid mode %r" % (options.mode, ))
return options
def run_worker_process(self):
setup_logger(self.quiet, log)
if self.registry_type == "UDP":
if self.registry_host is None:
self.registry_host = "255.255.255.255"
self.registrar = UDPRegistryClient(ip=self.registry_host,
port=self.registry_port)
else:
if self.registry_host is None:
raise ValueError(
"With TCP registry, you must specify --registry-host")
self.registrar = TCPRegistryClient(ip=self.registry_host,
port=self.registry_port)
t = ThreadPoolServer(ServiceEnvelope.SERVICE_CLASS,
hostname=self.host,
port=self.port,
reuse_addr=True,
ipv6=self.ipv6,
registrar=self.registrar,
auto_register=self.auto_register,
nbThreads=self.max_client_count,
requestBatchSize=self.max_requests_per_client,
protocol_config={
'exposed_prefix': '',
'log_exceptions': True
})
t.start()
def __init__(self,
service,
hostname="0.0.0.0",
port=0,
backlog=10,
reuse_addr=True,
authenticator=None,
registrar=None,
auto_register=True,
protocol_config={},
logger=None):
self.active = False
self._closed = False
self.service = service
self.authenticator = authenticator
self.backlog = backlog
self.auto_register = auto_register
self.protocol_config = protocol_config
self.clients = set()
self.listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if reuse_addr and sys.platform != "win32":
# warning: reuseaddr is not what you expect on windows!
self.listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.listener.bind((hostname, port))
self.port = self.listener.getsockname()[1]
if logger is None:
logger = self._get_logger()
self.logger = logger
if registrar is None:
registrar = UDPRegistryClient(logger=self.logger)
self.registrar = registrar
def service01():
conn = rpyc.connect(host='localhost', port=18861)
root = conn.root # MyService object
# object
print root
print root.get_service_name()
print root.get_service_aliases()
# custom method
print root.get_answer() # 66
print root.exposed_get_answer() # 66
# print root.get_question() # AttributeError: cannot access 'get_question'
registrar = UDPRegistryClient()
list_of_servers = registrar.discover("foo")
print rpyc.discover(service_name='MY', host='localhost')
def service01():
conn = rpyc.connect(host='localhost', port=18861)
root = conn.root # MyService object
# object
print root
print root.get_service_name()
print root.get_service_aliases()
# custom method
print root.get_answer() # 66
print root.exposed_get_answer() # 66
# print root.get_question() # AttributeError: cannot access 'get_question'
registrar = UDPRegistryClient()
list_of_servers = registrar.discover("foo")
print rpyc.discover(service_name='MY', host='localhost')
def __init__(self, service, hostname="", ipv6=False, port=0,
backlog=socket.SOMAXCONN, reuse_addr=True, authenticator=None, registrar=None,
auto_register=None, protocol_config=None, logger=None, listener_timeout=0.5,
socket_path=None):
self.active = False
self._closed = False
self.service = service
self.authenticator = authenticator
self.backlog = backlog
if auto_register is None:
self.auto_register = bool(registrar)
else:
self.auto_register = auto_register
if protocol_config is None:
protocol_config = {}
self.protocol_config = protocol_config
self.clients = set()
if socket_path is not None:
if hostname != "" or port != 0 or ipv6 is not False:
raise ValueError("socket_path is mutually exclusive with: hostname, port, ipv6")
self.listener = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.listener.bind(socket_path)
# set the self.port to the path as it's used for the registry and logging
self.host, self.port = "", socket_path
else:
if ipv6:
if hostname == "localhost" and sys.platform != "win32":
# on windows, you should bind to localhost even for ipv6
hostname = "localhost6"
self.listener = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
else:
self.listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if reuse_addr and sys.platform != "win32":
# warning: reuseaddr is not what you'd expect on windows!
# it allows you to bind an already bound port, resulting in
# "unexpected behavior" (quoting MSDN)
self.listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.listener.bind((hostname, port))
self.listener.settimeout(listener_timeout)
# hack for IPv6 (the tuple can be longer than 2)
sockname = self.listener.getsockname()
self.host, self.port = sockname[0], sockname[1]
if logger is None:
logger = logging.getLogger("%s/%s" % (self.service.get_service_name(), self.port))
self.logger = logger
if "logger" not in self.protocol_config:
self.protocol_config["logger"] = self.logger
if registrar is None:
registrar = UDPRegistryClient(logger=self.logger)
self.registrar = registrar
def main(self):
if self.registry_type == "UDP":
if self.registry_host is None:
self.registry_host = "255.255.255.255"
self.registrar = UDPRegistryClient(
ip=self.registry_host, port=self.registry_port)
else:
if self.registry_host is None:
raise ValueError(
"With TCP registry, you must specify --registry-host")
self.registrar = TCPRegistryClient(
ip=self.registry_host, port=self.registry_port)
if self.ssl_keyfile:
self.authenticator = SSLAuthenticator(
self.ssl_keyfile, self.ssl_certfile, self.ssl_cafile)
default_port = DEFAULT_SERVER_SSL_PORT
else:
self.authenticator = None
default_port = DEFAULT_SERVER_PORT
if self.port is None:
self.port = default_port
setup_logger(self.quiet, self.logfile)
sys.stdout.write(
BANNER + " starting at %s %s\n" %
(self.host, self.port))
sys.stdout.flush()
done_event = threading.Event()
srv = WeirdServer(
SlaveService,
done_event,
hostname=self.host,
port=self.port,
reuse_addr=True,
ipv6=self.ipv6,
authenticator=self.authenticator,
registrar=self.registrar,
auto_register=self.auto_register)
t = threading.Thread(target=self._serve, args=[srv])
t.start()
# wait for 2 connections
done_event.wait()
IPython.embed(
banner1=BANNER + " client connected\n",
banner2="", # "tip: call serve_all() on the client to have a full working shell here.",
exit_msg=BANNER + " shell closed.\nexiting...\n"
)
os.kill(srv.proc, signal.SIGKILL)
os._exit(0)
def __init__(self,
service,
hostname="",
ipv6=False,
port=0,
backlog=10,
reuse_addr=True,
authenticator=None,
registrar=None,
auto_register=None,
protocol_config={},
logger=None,
listener_timeout=0.5):
self.active = False
self._closed = False
self.service = service
self.authenticator = authenticator
self.backlog = backlog
if auto_register is None:
self.auto_register = bool(registrar)
else:
self.auto_register = auto_register
self.protocol_config = protocol_config
self.clients = set()
if ipv6:
if hostname == "localhost" and sys.platform != "win32":
# on windows, you should bind to localhost even for ipv6
hostname = "localhost6"
self.listener = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
else:
self.listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if reuse_addr and sys.platform != "win32":
# warning: reuseaddr is not what you'd expect on windows!
# it allows you to bind an already bound port, resulting in "unexpected behavior"
# (quoting MSDN)
self.listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.listener.bind((hostname, port))
self.listener.settimeout(listener_timeout)
# hack for IPv6 (the tuple can be longer than 2)
sockname = self.listener.getsockname()
self.host, self.port = sockname[0], sockname[1]
if logger is None:
logger = logging.getLogger(
"%s/%d" % (self.service.get_service_name(), self.port))
self.logger = logger
if "logger" not in self.protocol_config:
self.protocol_config["logger"] = self.logger
if registrar is None:
registrar = UDPRegistryClient(logger=self.logger)
self.registrar = registrar
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 start_server():
trivial_util.print_t('register consumer.')
producer = Producer.get_instance()
consumer = Consumer(producer)
consumer.process()
trivial_util.print_t('start server.')
args = _input_args
registrar = UDPRegistryClient(ip = args['registry_host'], port=args['registry_port'])
s = ThreadedServer(CentralControlService, hostname=args['server_host'], port=args['server_port'], registrar=registrar, auto_register=True, listener_timeout=DEFAULT_LISTEN_TIMEOUT)
s.start()
def discover(service_name, host = None, registrar = None, timeout = 2):
"""discovers hosts running the given service
service_name - the service to look for
host - limit the discovery to the given host only (None means any host)
registrar - use this registry client to discover services. if None,
use the default UDPRegistryClient with the default settings.
timeout - the number of seconds to wait for a reply from the registry
if no hosts are found, raises DiscoveryError
returns a list of (ip, port) pairs
"""
if registrar is None:
registrar = UDPRegistryClient(timeout=timeout)
addrs = registrar.discover(service_name)
if not addrs:
raise DiscoveryError("no servers exposing {0} were found".format(service_name))
if host:
ips = socket.gethostbyname_ex(host)[2]
addrs = [(h, p) for h, p in addrs if h in ips]
if not addrs:
raise DiscoveryError("no servers exposing {0} were found on {1}".format(service_name, host))
return addrs
def __init__(self, port=0, shutdown_callback=None):
super(AppServer, self).__init__(
AppService,
port=port,
registrar=UDPRegistryClient(
ip="255.255.255.255",
port=REGISTRY_PORT
),
auto_register=False,
)
# give the service a handle to the server for closing
self.service.server = self
self.service.shutdown_callback = shutdown_callback
def main(self):
if self.registry_type == "UDP":
if self.registry_host is None:
self.registry_host = "255.255.255.255"
self.registrar = UDPRegistryClient(ip=self.registry_host,
port=self.registry_port)
else:
if self.registry_host is None:
raise ValueError(
"With TCP registry, you must specify --registry-host")
self.registrar = TCPRegistryClient(ip=self.registry_host,
port=self.registry_port)
if self.ssl_keyfile:
self.authenticator = SSLAuthenticator(self.ssl_keyfile,
self.ssl_certfile,
self.ssl_cafile)
default_port = DEFAULT_SERVER_SSL_PORT
else:
self.authenticator = None
default_port = DEFAULT_SERVER_PORT
if self.port is None:
self.port = default_port
self.logger = logging.getLogger(__name__)
self.logger.setLevel(logging.DEBUG)
formatter = logging.Formatter(
"[%(asctime)s]-[%(levelname)s]-[%(filename)s:%(funcName)s:%(lineno)s]- %(message)s"
)
stream = logging.FileHandler(self.logfile, mode="w")
stream.setFormatter(formatter)
stream.setLevel(logging.DEBUG)
self.logger.addHandler(stream)
# print("**************" + self.logfile)
# setup_logger(self.quiet, self.logfile)
if self.mode == "threaded":
self._serve_mode(ThreadedServer)
elif self.mode == "forking":
self._serve_mode(ForkingServer)
elif self.mode == "oneshot":
self._serve_oneshot()
elif self.mode == "stdio":
self._serve_stdio()
def get_options():
options, args = parser.parse_args()
if args:
parser.error("does not take positional arguments: %r" % (args, ))
options.mode = options.mode.lower()
if options.regtype.lower() == "udp":
if options.reghost is None:
options.reghost = "255.255.255.255"
options.registrar = UDPRegistryClient(ip=options.reghost,
port=options.regport)
elif options.regtype.lower() == "tcp":
if options.reghost is None:
parser.error("must specific --registry-host")
options.registrar = TCPRegistryClient(ip=options.reghost,
port=options.regport)
else:
parser.error("invalid registry type %r" % (options.regtype, ))
if options.vdbfile:
if not os.path.exists(options.vdbfile):
parser.error("vdb file does not exist")
options.authenticator = TlsliteVdbAuthenticator.from_file(
options.vdbfile, mode="r")
if options.ssl_keyfile or options.ssl_certfile or options.ssl_cafile:
if not options.ssl_keyfile:
parser.error("SSL: keyfile required")
if not options.ssl_certfile:
parser.error("SSL: certfile required")
options.authenticator = SSLAuthenticator(options.ssl_keyfile,
options.ssl_certfile,
options.ssl_cafile)
if not options.port:
options.port = DEFAULT_SERVER_SSL_PORT
else:
options.authenticator = None
if not options.port:
options.port = DEFAULT_SERVER_PORT
options.handler = "serve_%s" % (options.mode, )
if options.handler not in globals():
parser.error("invalid mode %r" % (options.mode, ))
return options
def start_server():
obj = AppService()
args = _input_args
registrar = UDPRegistryClient(ip=args['registry_host'], port=args['registry_port'])
s = ThreadedServer(obj, hostname=args['server_host'], port=args['server_port'], registrar=registrar, auto_register=True, listener_timeout=DEFAULT_LISTEN_TIMEOUT)
s.start()
def _get_client(self):
return UDPRegistryClient()
