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