def main(serve_bootstrap=True, host="*", port=10000, reg_sturdy_ref=None):
config = {
"port": port,
"host": host,
"reg_sturdy_ref": reg_sturdy_ref,
"serve_bootstrap": str(serve_bootstrap),
"reg_category": "climate",
}
# read commandline args only if script is invoked directly from commandline
if len(sys.argv) > 1 and __name__ == "__main__":
for arg in sys.argv[1:]:
k, v = arg.split("=")
if k in config:
config[k] = v
print(config)
conMan = common.ConnectionManager()
service = Factory()
admin = serv.Admin(service)
service.admin = admin
restorer = common.Restorer()
if config["reg_sturdy_ref"]:
registrator = conMan.try_connect(config["reg_sturdy_ref"],
cast_as=reg_capnp.Registrator)
if registrator:
unreg = registrator.register(
ref=service, categoryId=config["reg_category"]).wait()
print("Registered ", config["name"], "climate service.")
#await unreg.unregister.unregister().a_wait()
else:
print("Couldn't connect to registrator at sturdy_ref:",
config["reg_sturdy_ref"])
addr = config["host"] + (
(":" + str(config["port"])) if config["port"] else "")
if config["serve_bootstrap"].lower() == "true":
server = capnp.TwoPartyServer(addr, bootstrap=restorer)
restorer.port = port if port else server.port
admin_sr = restorer.save(admin)
service_sr = restorer.save(service)
print("admin_sr:", admin_sr)
print("service_sr:", service_sr)
print("restorer_sr:", restorer.sturdy_ref())
else:
capnp.wait_forever()
server.run_forever()
def main():
subworker_id = get_environ_int("RAIN_SUBWORKER_ID")
print("Initalizing subworker {} ...".format(subworker_id))
print("Working directory: ".format(os.getcwd()))
sys.stdout.flush()
os.makedirs("task")
os.makedirs("stage")
stage_path = os.path.abspath("stage")
task_path = os.path.abspath("task")
Subworker(get_environ("RAIN_SUBWORKER_SOCKET"), subworker_id, task_path,
stage_path)
print("Subworker initialized")
sys.stdout.flush()
capnp.wait_forever()
def run_server():
_ = capnp.TwoPartyServer(write, bootstrap=Server())
capnp.wait_forever()
def init_and_run_fbp_component(component_cap,
name_to_in_ports={},
name_to_out_ports={},
host="*",
port=None,
serve_bootstrap=True,
restorer=None,
conman=None,
run_before_enter_eventloop=None,
eventloop_wait_forever=True):
host = host if host else "*"
if not conman:
conman = common.ConnectionManager()
if not restorer:
restorer = common.Restorer()
def connect_ports(side, name_to_ports, port_type):
for name, data in name_to_ports.items():
# only connect via sr if port is not already containing a capability
if "sr" in data and data["port"] is None:
try:
print("trying to connect", side, "port:", name, " via sr:",
data["sr"])
data["port"] = conman.try_connect(data["sr"],
cast_as=port_type,
retry_secs=1)
except Exception as e:
print("Error connecting to", side, "port:", name,
". Exception:", e)
addr = host + ((":" + str(port)) if port else "")
if serve_bootstrap:
server = capnp.TwoPartyServer(addr, bootstrap=restorer)
restorer.port = port if port else server.port
connect_ports("in", name_to_in_ports, common_capnp.Reader)
connect_ports("out", name_to_out_ports, common_capnp.Writer)
else:
connect_ports("in", name_to_in_ports, common_capnp.Reader)
connect_ports("out", name_to_out_ports, common_capnp.Writer)
if run_before_enter_eventloop:
run_before_enter_eventloop()
if eventloop_wait_forever:
capnp.wait_forever()
ips = []
for name, pd in name_to_in_ports.items():
ops.append({"name": name, "port": pd["port"]})
ops = []
for name, pd in name_to_out_ports.items():
ops.append({"name": name, "port": pd["port"]})
component_cap.setupPorts(inPorts=ips, outPorts=ops).wait()
if run_before_enter_eventloop:
run_before_enter_eventloop()
if eventloop_wait_forever:
server.run_forever()
def run_server():
restorer = SimpleRestorer()
server = capnp.TwoPartyServer(write, restorer)
capnp.wait_forever()
def init_and_run_service(name_to_service,
host="*",
port=None,
serve_bootstrap=True,
restorer=None,
conman=None,
name_to_service_srs={},
run_before_enter_eventloop=None,
**kwargs):
host = host if host else "*"
# check for sturdy ref inputs
if not sys.stdin.isatty():
try:
reg_config = json.loads(sys.stdin.read())
#print("read from stdin:", reg_config)
except Exception as e:
print("service.py: Error reading from sys.stdin. Exception:", e)
pass
else:
reg_config = {}
if not conman:
conman = common.ConnectionManager()
if not restorer:
restorer = common.Restorer()
#create and register admin with services
admin = Admin(list(name_to_service.values()))
for s in name_to_service.values():
if isinstance(s, AdministrableService):
s.admin = admin
if "admin" not in name_to_service and admin not in name_to_service.values(
):
name_to_service["admin"] = admin
def register_services(conman, admin, reg_config):
for name, data in reg_config.items():
try:
if isinstance(data, dict):
reg_sr = data["reg_sr"]
reg_name = data.get("reg_name", "")
reg_cat_id = data.get("cat_id", "")
elif isinstance(data, str):
reg_sr = data
reg_name = ""
reg_cat_id = ""
else:
continue
print("trying to register name:", name, "data:", data)
registrar = conman.try_connect(reg_sr,
cast_as=reg_capnp.Registrar)
if registrar and name in name_to_service:
r = registrar.register(cap=name_to_service[name],
regName=reg_name,
categoryId=reg_cat_id).wait()
unreg_action = r.unreg
rereg_sr = r.reregSR
admin.store_unreg_data(name, unreg_action, rereg_sr)
print("Registered", name, "in category '", reg_cat_id,
"' as '", reg_name, "'.")
else:
print("Couldn't connect to registrar at sturdy_ref:",
reg_sr)
except Exception as e:
print("Error registering service name:", name, ". Exception:",
e)
addr = host + ((":" + str(port)) if port else "")
if serve_bootstrap:
server = capnp.TwoPartyServer(addr, bootstrap=restorer)
restorer.port = port if port else server.port
for name, s in name_to_service.items():
service_sr, service_unsave_sr = restorer.save(
s, name_to_service_srs.get(name, None))
name_to_service_srs[name] = service_sr
print("service:", name, "sr:", service_sr)
print("restorer_sr:", restorer.sturdy_ref())
register_services(conman, admin, reg_config)
else:
register_services(conman, admin, reg_config)
if run_before_enter_eventloop:
run_before_enter_eventloop()
capnp.wait_forever()
if run_before_enter_eventloop:
run_before_enter_eventloop()
server.run_forever()
def run_server():
restorer = SimpleRestorer()
server = capnp.TwoPartyServer(write, restorer)
capnp.wait_forever()