def activate_applications(cfgfiles, debug, error):
"""Initialize applications
In:
- ``cfgfile`` -- paths to application configuration files or names of
registered applications
- ``debug`` -- enable the display of the generated SQL statements
- ``error`` -- the function to call in case of configuration errors
Return:
- database session
- {application name -> application object}
"""
# Configure the local service
local.worker = local.Process()
local.request = local.Process()
configs = []
# Merge all the ``[logging]]`` section of all the applications
for cfgfile in cfgfiles:
# Read the configuration file of the application
conffile, app, project_name, aconf = util.read_application(
cfgfile, error)
if conffile is None:
error('Configuration file "%s" not found' % cfgfile)
configs.append((conffile, app, project_name, aconf))
log.configure(aconf['logging'].dict(), aconf['application']['app'])
# Configure the logging service
log.activate()
apps = {}
# For each application given, activate its metadata and its logger
for cfgfile, app, project_name, aconf in configs:
name = aconf['application']['app']
log.set_logger('nagare.application.' + name)
data_path = aconf['application']['data']
apps[name], databases = util.activate_WSGIApp(app,
cfgfile,
aconf,
error,
data_path=data_path,
debug=debug)
for database_settings, populate in databases:
database.set_metadata(*database_settings)
session = database.session
session.begin()
return session, apps
def activate_applications(cfgfiles, debug, error):
"""Initialize applications
In:
- ``cfgfile`` -- paths to application configuration files or names of
registered applications
- ``debug`` -- enable the display of the generated SQL statements
- ``error`` -- the function to call in case of configuration errors
Return:
- database session
- {application name -> application object}
"""
# Configure the local service
local.worker = local.Process()
local.request = local.Process()
configs = []
# Merge all the ``[logging]]`` section of all the applications
for cfgfile in cfgfiles:
# Read the configuration file of the application
conffile, app, project_name, aconf = util.read_application(cfgfile, error)
if conffile is None:
error('Configuration file "%s" not found' % cfgfile)
configs.append((conffile, app, project_name, aconf))
log.configure(aconf['logging'].dict(), aconf['application']['app'])
# Configure the logging service
log.activate()
apps = {}
# For each application given, activate its metadata and its logger
for cfgfile, app, project_name, aconf in configs:
name = aconf['application']['app']
log.set_logger('nagare.application.' + name)
data_path = aconf['application']['data']
apps[name], databases = util.activate_WSGIApp(app, cfgfile, aconf, error, data_path=data_path, debug=debug)
for database_settings, populate in databases:
database.set_metadata(*database_settings)
session = database.session
session.begin()
return session, apps
def create_globals(cfgfiles, debug, error):
"""
In:
- ``cfgfile`` -- paths to application configuration files or names of
registered applications
- ``debug`` -- enable the display of the generated SQL statements
- ``error`` -- the function to call in case of configuration errors
Return:
- the namespace with the ``apps`` and ``session`` variables defined
"""
# Configure the local service
local.worker = local.Process()
local.request = local.Process()
configs = []
# Merge all the ``[logging]]`` section of all the applications
for cfgfile in cfgfiles:
# Read the configuration file of the application
(cfgfile, app, dist, aconf) = util.read_application(cfgfile, error)
configs.append((cfgfile, app, dist, aconf))
log.configure(aconf['logging'].dict(), aconf['application']['name'])
# Configure the logging service
log.activate()
apps = {}
# For each application given, activate its metadata and its logger
for (cfgfile, app, dist, aconf) in configs:
name = aconf['application']['name']
log.set_logger('nagare.application.'+name)
requirement = None if not dist else pkg_resources.Requirement.parse(dist.project_name)
data_path = None if not requirement else pkg_resources.resource_filename(requirement, '/data')
(apps[name], databases) = util.activate_WSGIApp(app, cfgfile, aconf, error, data_path=data_path, debug=debug)
for (database_settings, populate) in databases:
database.set_metadata(*database_settings)
session = database.session
session.begin()
return dict(session=session, apps=apps)
def read_options(debug, args, error):
"""Activate all the database metadata objects of an application
Several metadata objects can be activated if there are sub-sections into
the [database] section.
In:
- ``debug`` -- flag to display the generated SQL statements
- ``args`` -- arguments in the command lines: application to activate
- ``error`` -- the function to call in case of configuration errors
Return:
- tuples (metadata object, populate function)
"""
# If no application name is given, display the list of the registered applications
if not args:
print 'Available applications:'
app_names = [
entry.name
for entry in pkg_resources.iter_entry_points('nagare.applications')
]
for app_name in sorted(app_names):
print ' -', app_name
return ()
if len(args) != 1:
error('Bad number of parameters')
# Read the configuration of the application
cfgfile, app, project_name, aconf = util.read_application(args[0], error)
if cfgfile is None:
error('Configuration file not found')
# Configure the local service
local.worker = local.Process()
local.request = local.Process()
# Configure the logging service
log.configure(aconf['logging'].dict(), aconf['application']['name'])
log.activate()
log.set_logger('nagare.application.' + aconf['application']['name'])
return util.activate_WSGIApp(app, cfgfile, aconf, error, debug=debug)[1]
def run(parser, options, args):
for cfg in args:
(cfgfile, app, dist, conf) = util.read_application(cfg,
parser.error)
requirement = (
None if not dist
else pkg_resources.Requirement.parse(dist.project_name)
)
data_path = (
None if not requirement
else pkg_resources.resource_filename(requirement, '/data')
)
(active_app, databases) = util.activate_WSGIApp(
app, cfgfile, conf, parser.error, data_path=data_path)
for (database_settings, populate) in databases:
database.set_metadata(*database_settings)
if active_app:
rebuild_index(active_app)
def read_options(debug, args, error):
"""Activate all the database metadata objects of an application
Several metadata objects can be activated if there are sub-sections into
the [database] section.
In:
- ``debug`` -- flag to display the generated SQL statements
- ``args`` -- arguments in the command lines: application to activate
- ``error`` -- the function to call in case of configuration errors
Return:
- tuples (metadata object, populate function)
"""
# If no application name is given, display the list of the registered applications
if not args:
print 'Available applications:'
app_names = [entry.name for entry in pkg_resources.iter_entry_points('nagare.applications')]
for app_name in sorted(app_names):
print ' -', app_name
return ()
if len(args) != 1:
error('Bad number of parameters')
# Read the configuration of the application
cfgfile, app, project_name, aconf = util.read_application(args[0], error)
if cfgfile is None:
error('Configuration file not found')
# Configure the local service
local.worker = local.Process()
local.request = local.Process()
# Configure the logging service
log.configure(aconf['logging'].dict(), aconf['application']['name'])
log.activate()
log.set_logger('nagare.application.' + aconf['application']['name'])
return util.activate_WSGIApp(app, cfgfile, aconf, error, debug=debug)[1]
def run(parser, options, args):
try:
application = args[0]
except IndexError:
application = 'kansha'
(cfgfile, app, dist,
conf) = util.read_application(application, parser.error)
requirement = (None if not dist else pkg_resources.Requirement.parse(
dist.project_name))
data_path = (None if not requirement else
pkg_resources.resource_filename(requirement, '/data'))
(active_app, databases) = util.activate_WSGIApp(app,
cfgfile,
conf,
parser.error,
data_path=data_path)
for (database_settings, populate) in databases:
database.set_metadata(*database_settings)
if active_app:
rebuild_index(active_app)
def run(parser, options, args):
try:
application = args[0]
except IndexError:
application = 'kansha'
(cfgfile, app, dist, conf) = util.read_application(application,
parser.error)
requirement = (
None if not dist
else pkg_resources.Requirement.parse(dist.project_name)
)
data_path = (
None if not requirement
else pkg_resources.resource_filename(requirement, '/data')
)
(active_app, databases) = util.activate_WSGIApp(
app, cfgfile, conf, parser.error, data_path=data_path)
for (database_settings, populate) in databases:
database.set_metadata(*database_settings)
if active_app:
create_demo(active_app)
def run(parser, options, args):
"""Launch one or more applications
In:
- ``parser`` -- the ``optparse.OptParser`` object used to parse the configuration file
- ``options`` -- options in the command lines
- ``args`` -- arguments in the command lines
The arguments are a list of names of registered applications
or paths to application configuration files.
"""
# If no argument are given, display the list of the registered applications
if not args:
print 'Available applications:'
# The applications are registered under the ``nagare.applications`` entry point
applications = pkg_resources.iter_entry_points('nagare.applications')
for name in sorted(application.name for application in applications):
print ' -', name
return
# Read the (optional) publisher configuration file
pconf = read_publisher_options(parser, options)
if pconf['reloader']['activated']:
if 'nagare_reloaded' not in os.environ:
return reloader.restart_with_monitor()
filenames = pconf['reloader'].get('files', [])
if isinstance(filenames, basestring):
filenames = [filenames]
filenames = filter(os.path.isfile, filenames)
if options.conf:
filenames.append(options.conf)
watcher = reloader.install(pconf['reloader']['interval'], filenames, (pkg_resources.get_default_cache(),))
else:
watcher = None
# Load the publisher
publishers = {entry.name: entry for entry in pkg_resources.iter_entry_points('nagare.publishers')}
t = pconf['publisher']['type']
publisher = publishers[t].load()()
# If no port is given, set the port number according to the used publisher
if pconf['publisher']['port'] == -1:
pconf['publisher']['port'] = publisher.default_port
configs = []
# Merge all the ``[logging]`` section of all the applications
for cfgfile in args:
# Read the configuration file of the application
conffile, app, project_name, aconf = util.read_application(cfgfile, parser.error)
if conffile is None:
parser.error('Configuration file not found for application "%s"' % cfgfile)
configs.append((conffile, app, project_name, aconf))
log.configure(aconf['logging'].dict(), aconf['application']['app'])
# Configure the logging service
log.activate()
# Configure each application and register it to the publisher
for cfgfile, app, project_name, aconf in configs:
# log.set_logger('nagare.application.'+aconf['application']['name'])
if watcher:
watcher.watch_file(aconf.filename)
app_url = aconf['application']['name']
static_path = aconf['application']['static']
if os.path.isdir(static_path):
# Register the function to serve the static contents of the application
static_url = publisher.register_static(
app_url,
lambda path, static_path=static_path: get_file_from_root(static_path, path)
)
else:
static_path = static_url = None
data_path = aconf['application']['data']
if not os.path.isdir(data_path):
data_path = None
# Load the sessions manager factory
sessions_managers = {entry.name: entry for entry in pkg_resources.iter_entry_points('nagare.sessions')}
conf = pconf['sessions'].dict()
conf.update(aconf['sessions'].dict())
t = conf.pop('type')
sessions_manager = sessions_managers[t].load()()
sessions_manager.set_config(options.conf, conf, parser.error)
app, metadatas = util.activate_WSGIApp(
app,
cfgfile, aconf, parser.error,
project_name,
static_path, static_url,
data_path,
publisher,
sessions_manager
)
# Register the application to the publisher
publisher.register_application(
aconf['application']['app'],
app_url,
app,
create_wsgi_pipe(app, options, cfgfile, aconf, parser.error)
)
# Register the function to serve the static contents of the framework
nagare = pkg_resources.Requirement.parse('nagare')
nagare_location = pkg_resources.resource_filename(nagare, 'nagare')
publisher.register_static(
'nagare',
lambda path, root=os.path.join(nagare_location, 'static'): get_file_from_root(root, path)
)
# Launch all the applications
publisher.serve(options.conf, pconf['publisher'], parser.error)
def run(parser, options, args):
"""Launch one or more applications
In:
- ``parser`` -- the ``optparse.OptParser`` object used to parse the configuration file
- ``options`` -- options in the command lines
- ``args`` -- arguments in the command lines
The arguments are a list of names of registered applications
or paths to application configuration files.
"""
# If no argument are given, display the list of the registered applications
if len(args) == 0:
print 'Available applications:'
# The applications are registered under the ``nagare.applications`` entry point
applications = pkg_resources.iter_entry_points('nagare.applications')
for name in sorted([application.name for application in applications]):
print ' -', name
return
# Read the (optional) publisher configuration file
pconf = read_publisher_options(parser, options)
if pconf['reloader']['activated']:
if 'nagare_reloaded' not in os.environ:
return reloader.restart_with_monitor()
filenames = pconf['reloader'].get('files', [])
if isinstance(filenames, basestring):
filenames = [filenames]
filenames = filter(os.path.isfile, filenames)
if options.conf:
filenames.append(options.conf)
watcher = reloader.install(pconf['reloader']['interval'], filenames, (pkg_resources.get_default_cache(),))
else:
watcher = None
# Load the publisher
publishers = dict([(entry.name, entry) for entry in pkg_resources.iter_entry_points('nagare.publishers')])
t = pconf['publisher']['type']
publisher = publishers[t].load()()
# If no port is given, set the port number according to the used publisher
if pconf['publisher']['port'] == -1:
pconf['publisher']['port'] = publisher.default_port
configs = []
# Merge all the ``[logging]`` section of all the applications
for cfgfile in args:
# Read the configuration file of the application
(cfgfile, app, dist, aconf) = util.read_application(cfgfile, parser.error)
configs.append((cfgfile, app, dist, aconf))
log.configure(aconf['logging'].dict(), aconf['application']['name'])
# Configure the logging service
log.activate()
# Configure each application and register it to the publisher
for (cfgfile, app, dist, aconf) in configs:
#log.set_logger('nagare.application.'+aconf['application']['name'])
if watcher:
watcher.watch_file(aconf.filename)
requirement = None if not dist else pkg_resources.Requirement.parse(dist.project_name)
data_path = None if not requirement else pkg_resources.resource_filename(requirement, '/data')
# Create the function to get the static contents of the application
static_path = aconf['application'].get('static')
get_file = None
if static_path is not None and os.path.isdir(static_path):
# If a ``static`` parameter exists, under the ``[application]`` section,
# serve the static contents from this root
get_file = lambda path, static_path=static_path: get_file_from_root(static_path, path)
else:
# Else, serve the static from the ``static`` directory
# of the application package
if requirement:
get_file = lambda path, requirement=requirement: get_file_from_package(requirement, path)
static_path = pkg_resources.resource_filename(requirement, '/static')
# Register the function to serve the static contents of the application
static_url = publisher.register_static(aconf['application']['name'], get_file)
# Load the sessions manager factory
sessions_managers = dict([(entry.name, entry) for entry in pkg_resources.iter_entry_points('nagare.sessions')])
conf = pconf['sessions'].dict()
conf.update(aconf['sessions'].dict())
t = conf.pop('type')
sessions_manager = sessions_managers[t].load()()
sessions_manager.set_config(options.conf, conf, parser.error)
(app, metadatas) = util.activate_WSGIApp(
app,
cfgfile, aconf, parser.error,
'' if not dist else dist.project_name,
static_path, static_url,
data_path,
publisher,
sessions_manager
)
# Register the application to the publisher
publisher.register_application(
aconf['application']['path'],
aconf['application']['name'],
app,
create_wsgi_pipe(app, options, cfgfile, aconf, parser.error)
)
# Register the function to serve the static contents of the framework
publisher.register_static(
'nagare',
lambda path, r=pkg_resources.Requirement.parse('nagare'): get_file_from_package(r, path)
)
# Launch all the applications
publisher.serve(options.conf, pconf['publisher'], parser.error)
