def run(self):
container = create_container(self.config)
install_plugins(container, self.config.get('plugins', {}))
install_interfaces(container, self.config.get('interfaces', {}))
for cls_name in self.args.get('--interface', ()):
cls = import_object(cls_name)
container.install(cls)
if self.args.get('--debug'):
from gevent.backdoor import BackdoorServer
backdoor = BackdoorServer(('127.0.0.1', 5005), locals={'container': container})
gevent.spawn(backdoor.serve_forever)
def handle_signal():
logger.info('caught SIGINT/SIGTERM, pid=%s', os.getpid())
container.stop()
container.join()
sys.exit(0)
gevent.signal(signal.SIGINT, handle_signal)
gevent.signal(signal.SIGTERM, handle_signal)
setproctitle('lymph-instance (identity: %s, endpoint: %s, config: %s)' % (
container.identity,
container.endpoint,
self.config.source,
))
container.start(register=not self.args.get('--isolated', False))
if self.args.get('--reload'):
set_source_change_callback(container.stop)
container.join()
def _create_instance(self,
key,
instance_config,
default_class=None,
**kwargs):
if instance_config is None:
raise ConfigurationError("no config available for %r" % key)
clspath = instance_config.get('class', default_class)
if clspath is None:
raise ConfigurationError(
"no config available for %r (or no class configured)" % key)
if callable(clspath):
cls = clspath
else:
cls = import_object(clspath)
if hasattr(cls, 'from_config'):
return cls.from_config(instance_config, **kwargs)
else:
instance_config = copy.deepcopy(to_dict(instance_config))
instance_config.pop('class', None)
instance_config.update(kwargs)
return cls(**instance_config)
def install_interfaces(container, interfaces):
for name, instance_config in six.iteritems(interfaces):
try:
cls_name = instance_config['class']
except KeyError:
print("no instance class for '%s'" % name)
sys.exit(1)
cls = import_object(cls_name)
instance = container.install(cls)
instance.apply_config(instance_config)
def install_interfaces(container, interfaces):
for name, instance_config in six.iteritems(interfaces):
try:
cls_name = instance_config['class']
except KeyError:
print("no instance class for '%s'" % name)
sys.exit(1)
cls = import_object(cls_name)
instance = container.install_interface(cls, name=name)
instance.apply_config(instance_config)
def _get_interfaces(config):
interfaces = {}
for name, attrs in config.get('interfaces', {}).items():
cls = import_object(attrs['class'])
schema = generate(cls, name)
schema = schema.todict()
for k in schema:
if k in interfaces:
interfaces[k].update(schema[k])
else:
interfaces[k] = schema[k]
return interfaces
def _setup_container(self, debug):
self.container = create_container(self.config)
self.container.debug = debug
# Set global exception hook to send unhandled exception to the container's error_hook.
sys.excepthook = self.container.excepthook
install_plugins(self.container, self.config.get('plugins', {}))
install_interfaces(self.container, self.config.get('interfaces', {}))
for cls_name in self.args.get('--interface', ()):
cls = import_object(cls_name)
self.container.install_interface(cls)
def _setup_container(self, debug):
self.container = create_container(self.config)
self.container.debug = debug
# Set global exception hook to send unhandled exception to the container's error_hook.
sys.excepthook = self.container.excepthook
install_plugins(self.container, self.config.get('plugins', {}))
install_interfaces(self.container, self.config.get('interfaces', {}))
for cls_name in self.args.get('--interface', ()):
cls = import_object(cls_name)
self.container.install_interface(cls)
def install_interfaces(container, interfaces):
for name, instance_config in six.iteritems(interfaces):
try:
cls_name = instance_config['class']
except KeyError:
print("no instance class for '%s'" % name)
sys.exit(1)
cls = import_object(cls_name)
try:
interface = container.install_interface(cls, name=name)
except InterfaceSkipped as e:
logger.info("skipping interface %s: %s", name, e)
continue
interface.apply_config(instance_config)
def install_interfaces(container, interfaces):
for name_and_version, instance_config in six.iteritems(interfaces):
name, version = parse_versioned_name(name_and_version)
try:
cls_name = instance_config['class']
except KeyError:
print("no instance class for '%s'" % name_and_version)
sys.exit(1)
cls = import_object(cls_name)
try:
interface = container.install_interface(cls, name=name, version=version)
except InterfaceSkipped as e:
logger.info("skipping interface %s: %s", name, e)
continue
interface.apply_config(instance_config)
def _create_instance(self, key, instance_config, default_class=None, **kwargs):
if instance_config is None:
raise ConfigurationError("no config available for %r" % key)
clspath = instance_config.get('class', default_class)
if clspath is None:
raise ConfigurationError("no config available for %r (or no class configured)" % key)
cls = import_object(clspath)
if hasattr(cls, 'from_config'):
return cls.from_config(instance_config, **kwargs)
else:
instance_config = copy.deepcopy(dict(instance_config))
del instance_config['class']
instance_config.update(kwargs)
return cls(**instance_config)
def __init__(self, uri, base=Base, migrations=None, **kwargs):
if 'models' in kwargs:
warnings.warn("models argument was removed", DeprecationWarning)
timezone = kwargs.pop('timezone', 'utc')
connect_args = kwargs.pop('connect_args', {})
options = connect_args.get('options', '')
options = '%s -c timezone=%s' % (options, timezone)
connect_args.update({'options': options})
if isinstance(base, basestring):
base = import_object(base)
self.Base = base
self.migrations = migrations or {}
self._connection = kwargs.pop('connection', None)
self.engine = sqlalchemy.create_engine(uri,
connect_args=connect_args,
**kwargs)
self.init_session()
def __init__(self, uri, base=Base, migrations=None, **kwargs):
if 'models' in kwargs:
warnings.warn("models argument was removed", DeprecationWarning)
timezone = kwargs.pop('timezone', 'utc')
connect_args = kwargs.pop('connect_args', {})
options = connect_args.get('options', '')
options = '%s -c timezone=%s' % (options, timezone)
connect_args.update({
'options': options
})
if isinstance(base, basestring):
base = import_object(base)
self.Base = base
self.migrations = migrations or {}
self._connection = kwargs.pop('connection', None)
self.engine = sqlalchemy.create_engine(uri, connect_args=connect_args, **kwargs)
self.init_session()
def _create_instance(self, key, instance_config, default_class=None, **kwargs):
if instance_config is None:
raise ConfigurationError("no config available for %r" % key)
clspath = instance_config.get("class", default_class)
if clspath is None:
raise ConfigurationError("no config available for %r (or no class configured)" % key)
if callable(clspath):
cls = clspath
else:
cls = import_object(clspath)
if hasattr(cls, "from_config"):
return cls.from_config(instance_config, **kwargs)
else:
instance_config = copy.deepcopy(to_dict(instance_config))
instance_config.pop("class", None)
instance_config.update(kwargs)
return cls(**instance_config)
def install_plugins(container, plugins):
for name, plugin_config in six.iteritems(plugins):
cls = import_object(plugin_config['class'])
container.install_plugin(cls, **plugin_config)
def test_import_object(self):
from lymph.core.container import ServiceContainer
cls = import_object('lymph.core.container:ServiceContainer')
self.assertIs(cls, ServiceContainer)
def create_instance(self, key, default_class=None, **kwargs):
config = self.get(key, {})
path = config.get('class', default_class)
cls = import_object(path)
return cls.from_config(config, **kwargs)
def install_plugins(container, plugins):
for name, plugin_config in six.iteritems(plugins):
cls = import_object(plugin_config['class'])
container.install_plugin(cls, **plugin_config)
def test_import_object(self):
from lymph.core.container import ServiceContainer
cls = import_object('lymph.core.container:ServiceContainer')
self.assertIs(cls, ServiceContainer)
