def _parse_ui_elements(self, module_or_list):
if not module_or_list:
return {}
elif isinstance(module_or_list, compat.string_type):
module_name = module_or_list.split('.')[-1]
module_or_list = {module_name: module_or_list}
return {k: import_object(v) for k, v in module_or_list.iteritems()}
def add_transform(self, module_or_list):
if isinstance(module_or_list, compat.list_type):
self.transforms.extends(self._parse_transforms(module_or_list))
else:
if isinstance(module_or_list, compat.string_type):
module_or_list = import_object(module_or_list)
super(ServerApplication, self).add_transform(module_or_list)
def start_server(*args, **kwargs):
global __SERVER
debugcolorizer('### SERVER ###', fg='black', bg='blue')
logging.info('Starting server...')
if not settings.is_options_parsed():
options.parse_command_line()
settings.options_parse(options.options.as_dict())
settings_dict = settings.as_dict()
try:
module = None
for key in constants.APPLICATION_CLASS_LIST:
if key in settings_dict:
cls = settings_dict[key]
module = import_object(cls)
break
application = module(**settings_dict)
except:
application = ServerApplication(**settings_dict)
if settings.DEBUG:
code = jsoncolorize(jsondumps(settings_dict, indent=2, sort_keys=True))
logging.debug(' * Settings:\n\n%s\n\n', code)
http_server = httpserver.HTTPServer(
application, **{
'xheaders': settings.XHEADERS,
'ssl_options': application.ssl_options
})
io_loop = ioloop.IOLoop.current()
application.set_exit_callback(partial(_stop_loop, io_loop))
with stack_context.NullContext():
if settings.PREFORK_PROCESS > -1:
http_server.bind(settings.PORT)
http_server.start(settings.PREFORK_PROCESS)
else:
http_server.listen(settings.PORT)
yield gen.Task(application.start)
__SERVER = ServerEnvironment(settings.SERVER_NAME, application,
http_server, io_loop)
url = 'http://{domain}:{port}'.format(**settings_dict)
logging.info('%s v%s', __SERVER.name.upper(), __SERVER.version.value)
logging.info('Running server on %s', url)
logging.info('--')
if not compat.WIN and settings.DEBUG and not settings.DISABLE_BROWSER:
import subprocess
subprocess.Popen(['open', url])
yield gen.Task(lambda callback: None)
def _parse_handlers_list(self, module_or_list):
result = []
for item in module_or_list:
if isinstance(item, compat.list_type) and len(item) in (2, 3, 4):
result.append(item)
elif isinstance(item, compat.string_type):
values = import_object('%s.%s' % (item, DEFAULT_CONTAINER))
if not isinstance(values, compat.list_type):
raise ConfigurationError(
'Module "%s" does not define "%s" attribute like a list'
% (item, DEFAULT_CONTAINER))
result.extend(values)
else:
raise ConfigurationError('Element not supported: %s' % item)
return result
def factory(name=None, options=None, module=None, settings=None, **kwargs):
"""
Example:
--------
.. code-block:: python
options = {
'session': {
'module': 'path.to.module',
'settings': {
...
}
},
'cache': 'path.to.module'
}
module = factory('session', options)
# settings or keywords argument
settings = {
'name': 'sid',
'secure_cookie': True,
'adapter': {
'port': 11211,
'domain': 'localhost'
}
}
module = factory(module='path.to.module', settings=settings)
:param name: (string)
:param options: (dict)
:param settings: (dict)
:param module: (string or instance)
:param kwargs:
:return:
"""
if module is None:
if isinstance(name, compat.string_type) and isinstance(options, dict):
if name not in options:
raise FactoryError('Option not supported: %s' % name)
else:
opts = options[name]
if isinstance(opts, dict) and 'module' in opts:
module = opts['module'] or module
try:
settings = opts['settings']
except:
settings = settings
elif isinstance(opts, compat.string_type):
module = opts
else:
raise FactoryError(
'Please define into your "options" a dictionary '
'with a {"name": "path.to.module"} or '
'{"name": {"module": "module.to.path", "settings": {}}}'
)
else:
raise FactoryError('Bad configuration, you need to define the '
'argument "name" with "options" and/or '
'"settings", or maybe "module" and "settings"')
if isinstance(module, compat.string_type):
module = import_object(module)
if not callable(module):
raise FactoryError('The module must be callable or an object instance')
if settings:
kwargs.update(settings)
return module(**kwargs)
def _import_class(self, value):
return import_object(value)
def _parse_transforms(self, module_or_list):
if not module_or_list:
return []
elif isinstance(module_or_list, compat.string_type):
module_or_list = [module_or_list]
return [import_object(item) for item in module_or_list]