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 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 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 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 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 load_with(arg): d = Database() with open(arg.config, 'r') as f: clients = json.load(f)['clients'] d.record = {name: balance for name, balance in clients.items()} d.id, d.port, d.fail_rate = arg.id, arg.port, random.uniform(0., .2) d.registrar = TCPRegistryClient(arg.registrar)
def __init__(self): self.id = 0 self.fail_rate = 0. self.port = 12345 self.registrar = TCPRegistryClient("localhost") self.record = {} self.pending_transactions = {}
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 boot(self, ev): NodeService.setConfig(ev) thread = threading.Thread( target=ThreadedServer(NodeService, port=int(ev["port"]), registrar=TCPRegistryClient( ip="0.0.0.0", port=REGISTRY_PORT)).start) thread.daemon = True thread.start() self.logger.info("Node Service started")
def rpyc_start(server_instance): logging.basicConfig(stream=sys.stdout, level=logging.WARNING) #regisztralas from rpyc.utils.registry import TCPRegistryClient registrar = TCPRegistryClient(ip=server_instance.default_gateway) this.log('Registering service') #rpyc szerver inditasa from rpyc.utils.server import ThreadedServer t = ThreadedServer(server_instance, port=9600, listener_timeout=60, registrar=registrar, logger=logging.getLogger()) t.start()
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 _get_client(self): return TCPRegistryClient("localhost")
import argparse import random import rpyc from rpyc.utils.registry import TCPRegistryClient from rpyc.utils.server import ThreadedServer rpyc.core.protocol.DEFAULT_CONFIG['allow_pickle'] = True cfg = { "registrar": TCPRegistryClient("localhost"), "database": ("localhost", 12345) } class RouterService(rpyc.Service): def on_connect(self): found = cfg["registrar"].discover("DB") for addr, p in found: if p == cfg["database"]: self.db_node = rpyc.connect(addr, p) break else: raise RuntimeError('No databases found with port %d' % cfg["database"]) def on_disconnect(self): self.db_node = None def exposed_transaction_request(self, transaction): return self.db_node.root.transaction_request(transaction)
else: print('%s be salty!' % self.name) def get_closest_router(self): l = self.registrar.discover("Router") addr, port = random.choice(l) return rpyc.connect(addr, port) if __name__ == '__main__': parser = argparse.ArgumentParser(description='Starts a client') parser.add_argument('--config', type=str, default='tata_lor.json') parser.add_argument('--name', '-n', type=str, help='Name to use', required=True) parser.add_argument('--seed', '-s', type=int, help='RNG seed', default=42) parser.add_argument('--registrar', '-r', type=str, help='Registrar address', default='localhost') args = parser.parse_args() print('Sanity check Client') random.seed(args.seed) config = json.load(open(args.config, 'r')) assert args.name in config["clients"], "Unregistered name: %s" % args.name friends = [f for f in config["clients"] if f != args.name] c = Client(args.name, TCPRegistryClient(args.registrar)) while True: time.sleep(random.uniform(3, 5)) to = random.choice(friends) c.transact(to, random.randint(1, 15))