def runserver(self):
def _shutdown(signum, frame):
eventlet.spawn_n(runner.stop)
runner = ServiceRunner(config=config.to_dict())
# for service_cls in BaseService.__subclasses__():
# runner.add_service(service_cls)
runner.add_service(InvboxService)
signal.signal(signal.SIGTERM, _shutdown)
runner.start()
runnlet = eventlet.spawn(runner.wait)
while True:
try:
runnlet.wait()
except OSError as exc:
if exc.errno == errno.EINTR:
continue
raise
except KeyboardInterrupt:
print()
try:
runner.stop()
except KeyboardInterrupt:
print() # as above
runner.kill()
else:
break
def main():
config = {
'_log': LOG,
'AMQP_URI': 'amqp://*****:*****@127.0.0.1:5672'
}
service_runner = ServiceRunner(config)
service_runner.add_service(DatabaseService)
service_runner.start()
runnlet = eventlet.spawn(service_runner.wait)
while True:
try:
runnlet.wait()
except OSError as exc:
if exc.errno == errno.EINTR:
continue
raise
except KeyboardInterrupt:
try:
service_runner.stop()
except KeyboardInterrupt:
service_runner.kill()
else:
break
def service_container(patched_db):
config = {'AMQP_URI': settings.NAMEKO_AMQP_URI}
runner = ServiceRunner(config)
runner.add_service(NamekoCollectionService)
runner.start()
container = get_container(runner, NamekoCollectionService)
yield container
runner.stop()
def test_runner_lifecycle(fake_module):
events = set()
class Container(object):
def __init__(self, service_cls, config):
self.service_name = service_cls.__name__
self.service_cls = service_cls
def start(self):
events.add(('start', self.service_cls.name, self.service_cls))
def stop(self):
events.add(('stop', self.service_cls.name, self.service_cls))
def kill(self):
events.add(('kill', self.service_cls.name, self.service_cls))
def wait(self):
events.add(('wait', self.service_cls.name, self.service_cls))
fake_module.ServiceContainer = Container
config = {'SERVICE_CONTAINER_CLS': 'fake_module.ServiceContainer'}
runner = ServiceRunner(config)
runner.add_service(TestService1)
runner.add_service(TestService2)
runner.start()
assert events == {
('start', 'foobar_1', TestService1),
('start', 'foobar_2', TestService2),
}
events = set()
runner.stop()
assert events == {
('stop', 'foobar_1', TestService1),
('stop', 'foobar_2', TestService2),
}
events = set()
runner.kill()
assert events == {
('kill', 'foobar_1', TestService1),
('kill', 'foobar_2', TestService2),
}
events = set()
runner.wait()
assert events == {
('wait', 'foobar_1', TestService1),
('wait', 'foobar_2', TestService2),
}
def test_runner_lifecycle(fake_module):
events = set()
class Container(object):
def __init__(self, service_cls, config):
self.service_name = service_cls.__name__
self.service_cls = service_cls
def start(self):
events.add(('start', self.service_cls.name, self.service_cls))
def stop(self):
events.add(('stop', self.service_cls.name, self.service_cls))
def kill(self):
events.add(('kill', self.service_cls.name, self.service_cls))
def wait(self):
events.add(('wait', self.service_cls.name, self.service_cls))
fake_module.ServiceContainer = Container
config = {'SERVICE_CONTAINER_CLS': 'fake_module.ServiceContainer'}
runner = ServiceRunner(config)
runner.add_service(TestService1)
runner.add_service(TestService2)
runner.start()
assert events == {
('start', 'foobar_1', TestService1),
('start', 'foobar_2', TestService2),
}
events = set()
runner.stop()
assert events == {
('stop', 'foobar_1', TestService1),
('stop', 'foobar_2', TestService2),
}
events = set()
runner.kill()
assert events == {
('kill', 'foobar_1', TestService1),
('kill', 'foobar_2', TestService2),
}
events = set()
runner.wait()
assert events == {
('wait', 'foobar_1', TestService1),
('wait', 'foobar_2', TestService2),
}
def test_runner_lifecycle():
events = set()
class Container(object):
def __init__(self, service_cls, worker_ctx_cls, config):
self.service_name = service_cls.__name__
self.service_cls = service_cls
self.worker_ctx_cls = worker_ctx_cls
def start(self):
events.add(('start', self.service_cls.name, self.service_cls))
def stop(self):
events.add(('stop', self.service_cls.name, self.service_cls))
def kill(self):
events.add(('kill', self.service_cls.name, self.service_cls))
def wait(self):
events.add(('wait', self.service_cls.name, self.service_cls))
config = {}
runner = ServiceRunner(config, container_cls=Container)
runner.add_service(TestService1)
runner.add_service(TestService2)
runner.start()
assert events == {
('start', 'foobar_1', TestService1),
('start', 'foobar_2', TestService2),
}
events = set()
runner.stop()
assert events == {
('stop', 'foobar_1', TestService1),
('stop', 'foobar_2', TestService2),
}
events = set()
runner.kill()
assert events == {
('kill', 'foobar_1', TestService1),
('kill', 'foobar_2', TestService2),
}
events = set()
runner.wait()
assert events == {
('wait', 'foobar_1', TestService1),
('wait', 'foobar_2', TestService2),
}
def test_runner_lifecycle():
events = set()
class Container(object):
def __init__(self, service_cls, worker_ctx_cls, config):
self.service_name = service_cls.__name__
self.service_cls = service_cls
self.worker_ctx_cls = worker_ctx_cls
def start(self):
events.add(('start', self.service_cls.name, self.service_cls))
def stop(self):
events.add(('stop', self.service_cls.name, self.service_cls))
def kill(self):
events.add(('kill', self.service_cls.name, self.service_cls))
def wait(self):
events.add(('wait', self.service_cls.name, self.service_cls))
config = {}
runner = ServiceRunner(config, container_cls=Container)
runner.add_service(TestService1)
runner.add_service(TestService2)
runner.start()
assert events == {
('start', 'foobar_1', TestService1),
('start', 'foobar_2', TestService2),
}
events = set()
runner.stop()
assert events == {
('stop', 'foobar_1', TestService1),
('stop', 'foobar_2', TestService2),
}
events = set()
runner.kill()
assert events == {
('kill', 'foobar_1', TestService1),
('kill', 'foobar_2', TestService2),
}
events = set()
runner.wait()
assert events == {
('wait', 'foobar_1', TestService1),
('wait', 'foobar_2', TestService2),
}
def main():
config_dict = get_config_yaml(CONFIG_YAML_PATH)
c = update_config_yaml(config_dict, CONFIG_YAML_PATH)
runner = ServiceRunner(c)
runner.add_service(FetchURLService)
# container_a = get_container(runner, FetchURLService)
runner.start()
try:
runner.wait()
except KeyboardInterrupt:
runner.kill()
runner.stop()
def main():
import logging
logging.basicConfig(level=logging.DEBUG)
config = {'AMQP_URI': 'amqp://*****:*****@localhost:5672/'}
runner = ServiceRunner(config)
runner.add_service(MessagingPublisher)
runner.start()
try:
runner.wait()
except KeyboardInterrupt:
runner.stop()
def main():
logging.basicConfig(level=logging.DEBUG)
config = {'AMQP_URI': 'amqp://*****:*****@localhost:5672/'}
runner = ServiceRunner(config)
runner.add_service(HelloWorld)
runner.add_service(FriendlyService)
runner.start()
try:
runner.wait()
except KeyboardInterrupt:
runner.stop()
def test_service_integration():
config = {'AMQP_URI': 'amqp://*****:*****@localhost:5672/'}
runner = ServiceRunner(config)
runner.add_service(ServiceX)
runner.add_service(ServiceY)
runner.start()
container = get_container(runner, ServiceX)
with entrypoint_hook(container, "remote_method") as entrypoint:
assert entrypoint("value") == "value-x-y"
runner.stop()
def test_service_integration():
config = {"AMQP_URI": "amqp://*****:*****@localhost:5672/"}
runner = ServiceRunner(config)
runner.add_service(ServiceX)
runner.add_service(ServiceY)
runner.start()
container = get_container(runner, ServiceX)
with entrypoint_hook(container, "remote_method") as entrypoint:
assert entrypoint("value") == "value-x-y"
runner.stop()
def main():
import logging
logging.basicConfig(level=logging.DEBUG)
config = {'AMQP_URI': 'amqp://*****:*****@localhost:5672/'}
runner = ServiceRunner(config)
runner.add_service(AdderService)
runner.start()
try:
runner.wait()
except KeyboardInterrupt:
runner.stop()
def main():
config_dict = get_config_yaml(CONFIG_YAML_PATH)
c = update_config_yaml(config_dict, CONFIG_YAML_PATH)
wus = WatchURLService()
wus.get_config()
runner = ServiceRunner(c)
runner.add_service(WatchURLService)
# container_a = get_container(runner, WatchURLService)
runner.start()
try:
runner.wait()
except KeyboardInterrupt:
runner.kill()
runner.stop()
def main():
logging.basicConfig(level=logging.DEBUG)
# disable most logging so we can see the console
logger = logging.getLogger('')
logger.setLevel(logging.WARNING)
config = {'AMQP_URI': 'amqp://*****:*****@localhost:5672/chat'}
runner = ServiceRunner(config)
runner.add_service(Chat)
runner.start()
try:
runner.wait()
except KeyboardInterrupt:
runner.stop()
def handle(self, *args, **options):
runner = ServiceRunner(settings.AMQP_CONFIG)
runner.add_service(MasterService)
def shutdown(signum, frame):
eventlet.spawn_n(runner.kill)
signal.signal(signal.SIGTERM, shutdown)
runner.start()
try:
runner.wait()
except KeyboardInterrupt:
try:
runner.stop()
except KeyboardInterrupt:
runner.kill()
def main():
logging.basicConfig(level=logging.DEBUG)
# disable most logging so we can see the console
logger = logging.getLogger("")
logger.setLevel(logging.WARNING)
config = {"AMQP_URI": "amqp://*****:*****@localhost:5672/chat"}
runner = ServiceRunner(config)
runner.add_service(Chat)
runner.start()
try:
runner.wait()
except KeyboardInterrupt:
runner.stop()
def test_service_x_y_integration():
# run services in the normal manner
config = {'AMQP_URI': 'amqp://*****:*****@localhost:5672/'}
runner = ServiceRunner(config)
runner.add_service(ServiceX)
runner.add_service(ServiceY)
runner.start()
# artificially fire the "remote_method" entrypoint on ServiceX
# and verify response
container = get_container(runner, ServiceX)
with entrypoint_hook(container, "remote_method") as entrypoint:
assert entrypoint("value") == "value-x-y"
runner.stop()
def handle(self, *args, **options):
runner = ServiceRunner(settings.AMQP_CONFIG)
runner.add_service(MasterService)
def shutdown(signum, frame):
eventlet.spawn_n(runner.kill)
signal.signal(signal.SIGTERM, shutdown)
runner.start()
try:
runner.wait()
except KeyboardInterrupt:
try:
runner.stop()
except KeyboardInterrupt:
runner.kill()
def run(services, config, backdoor_port=None, rename=None):
service_runner = ServiceRunner(config)
for service_cls in services:
if rename and rename.get(service_cls.name):
service_cls.name = rename[service_cls.name]
service_runner.add_service(service_cls)
def shutdown(signum, frame):
# signal handlers are run by the MAINLOOP and cannot use eventlet
# primitives, so we have to call `stop` in a greenlet
eventlet.spawn_n(service_runner.stop)
signal.signal(signal.SIGTERM, shutdown)
if backdoor_port is not None:
setup_backdoor(service_runner, backdoor_port)
service_runner.start()
# if the signal handler fires while eventlet is waiting on a socket,
# the __main__ greenlet gets an OSError(4) "Interrupted system call".
# This is a side-effect of the eventlet hub mechanism. To protect nameko
# from seeing the exception, we wrap the runner.wait call in a greenlet
# spawned here, so that we can catch (and silence) the exception.
runnlet = eventlet.spawn(service_runner.wait)
while True:
try:
runnlet.wait()
except OSError as exc:
if exc.errno == errno.EINTR:
# this is the OSError(4) caused by the signalhandler.
# ignore and go back to waiting on the runner
continue
raise
except KeyboardInterrupt:
print() # looks nicer with the ^C e.g. bash prints in the terminal
try:
service_runner.stop()
except KeyboardInterrupt:
print() # as above
service_runner.kill()
else:
# runner.wait completed
break
def run(services, config, backdoor_port=None):
service_runner = ServiceRunner(config)
for service_cls in services:
service_runner.add_service(service_cls)
def shutdown(signum, frame):
# signal handlers are run by the MAINLOOP and cannot use eventlet
# primitives, so we have to call `stop` in a greenlet
eventlet.spawn_n(service_runner.stop)
signal.signal(signal.SIGTERM, shutdown)
if backdoor_port is not None:
setup_backdoor(service_runner, backdoor_port)
service_runner.start()
# if the signal handler fires while eventlet is waiting on a socket,
# the __main__ greenlet gets an OSError(4) "Interrupted system call".
# This is a side-effect of the eventlet hub mechanism. To protect nameko
# from seeing the exception, we wrap the runner.wait call in a greenlet
# spawned here, so that we can catch (and silence) the exception.
runnlet = eventlet.spawn(service_runner.wait)
while True:
try:
runnlet.wait()
except OSError as exc:
if exc.errno == errno.EINTR:
# this is the OSError(4) caused by the signalhandler.
# ignore and go back to waiting on the runner
continue
raise
except KeyboardInterrupt:
print() # looks nicer with the ^C e.g. bash prints in the terminal
try:
service_runner.stop()
except KeyboardInterrupt:
print() # as above
service_runner.kill()
else:
# runner.wait completed
break
def run_nameko(args):
# Running nameko imports here so that Eventgen as a module does not require nameko to run.
import eventlet
eventlet.monkey_patch()
from nameko.runners import ServiceRunner
# In order to make this run locally as well as within a container-ized environment, we're to pull variables
# from both environment variables and CLI arguments, where CLI will take precendence.
config = parse_env_vars()
config = parse_cli_vars(config, args)
config = rectify_config(config)
print "Config used: {}".format(config)
# Wait up to 30s for RMQ service to be up
wait_for_response(config["AMQP_URI"], config["AMQP_WEBPORT"])
# Start Nameko service
runner = ServiceRunner(config=config)
if args.role == "controller":
from eventgen_nameko_controller import EventgenController
runner.add_service(EventgenController)
else:
from eventgen_nameko_server import EventgenServer
runner.add_service(EventgenServer)
runner.start()
runnlet = eventlet.spawn(runner.wait)
while True:
try:
runnlet.wait()
except OSError as exc:
if exc.errno == errno.EINTR:
# this is the OSError(4) caused by the signalhandler.
# ignore and go back to waiting on the runner
continue
raise
except KeyboardInterrupt:
print() # looks nicer with the ^C e.g. bash prints in the terminal
try:
runner.stop()
except KeyboardInterrupt:
print() # as above
runner.kill()
else:
# runner.wait completed
break
def run():
config = {'AMQP_URI': 'amqp://localhost'}
runner = ServiceRunner(config)
runner.add_service(AlarmService)
runner.add_service(HttpEntrypointService)
runner.add_service(LightService)
runner.add_service(LocalStorageService)
runner.add_service(SpotifyService)
runner.add_service(VolumeService)
runner.start()
runnlet = eventlet.spawn(runner.wait)
try:
runnlet.wait()
except KeyboardInterrupt:
try:
runner.stop()
except KeyboardInterrupt:
runner.kill()
def run():
config = {'AMQP_URI': 'amqp://localhost'}
runner = ServiceRunner(config)
runner.add_service(AlarmService)
runner.add_service(HttpEntrypointService)
runner.add_service(LightService)
runner.add_service(LocalStorageService)
runner.add_service(SpotifyService)
runner.add_service(VolumeService)
runner.start()
runnlet = eventlet.spawn(runner.wait)
try:
runnlet.wait()
except KeyboardInterrupt:
try:
runner.stop()
except KeyboardInterrupt:
runner.kill()
def run_service(service_cls):
def _signal_handler(_signum, _frame):
"""
Handler on signal
"""
LOGGER.info('stop service')
eventlet.spawn(runner.stop)
params = get_args()
runner = ServiceRunner(config={})
service_cls.prepare(params)
runner.add_service(service_cls)
signal.signal(signal.SIGTERM, _signal_handler)
runner.start()
runnlet = eventlet.spawn(runner.wait)
LOGGER.info('Start service')
try:
runnlet.wait()
except KeyboardInterrupt:
LOGGER.info('Stop service')
runner.stop()
def run_all():
services = {}
for f in root.iterdir():
if f.is_dir() and f.name.endswith("Service") and f.name.startswith(
"Admin"):
name = f.name
service = importlib.import_module(name + '.service')
services[name] = service
from nameko.runners import ServiceRunner
runner = ServiceRunner(config={"AMQP_URI": "amqp://*****:*****@ip"})
for name, service in services.items():
cls = getattr(service, name)
print(name, service, cls)
runner.add_service(cls)
print('wsadsa')
runner.start()
try:
runner.wait()
except KeyboardInterrupt:
runner.kill()
runner.stop()
from nameko.runners import ServiceRunner
from nameko.testing.utils import get_container
class ServiceA(object):
name = "service_a"
class ServiceB(object):
name = "service_b"
# create a runner for ServiceA and ServiceB
runner = ServiceRunner(config={})
runner.add_service(ServiceA)
runner.add_service(ServiceB)
# ``get_container`` will return the container for a particular service
container_a = get_container(runner, ServiceA)
# start both services
runner.start()
# stop both services
runner.stop()
service_runner.start()
print("Started service")
try:
runlet.wait()
except OSError as exc:
if exc.errno == errno.EINTR:
# this is the OSError(4) caused by the signalhandler.
# ignore and go back to waiting on the runner
continue
raise
except KeyboardInterrupt:
print(
) # looks nicer with the ^C e.g. bash prints in the terminal
try:
service_runner.stop()
except KeyboardInterrupt:
print() # as above
service_runner.kill()
else:
# runlet.wait completed
break
print("Stopping service")
service_runner.stop()
except:
print(
"Exception. Pausing for a little and then retrying to start service"
)
time.sleep(5)
from nameko.runners import ServiceRunner
from nameko.utils import get_container
class ServiceA(object):
name = "service_a"
class ServiceB(object):
name = "service_b"
# create a runner for ServiceA and ServiceB
runner = ServiceRunner(config={})
runner.add_service(ServiceA)
runner.add_service(ServiceB)
# ``get_container`` will return the container for a particular service
container_a = get_container(runner, ServiceA)
# start both services
runner.start()
# stop both services
runner.stop()