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 __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()