def create_rules(app_names, error): """Generate the rewrite rules for the given registered applications In: - ``app_names`` -- list of the applications, read from the command line - ``error`` -- the function to call in case of configuration errors Return: - list of tuples (application, directory of its static contents) """ # If no applications is given on the command line, generate the rules # for all the registered applications if not app_names: app_names = [ entry.name for entry in pkg_resources.iter_entry_points('nagare.applications') ] package = pkg_resources.Requirement.parse('nagare') static = os.path.join(pkg_resources.resource_filename(package, 'nagare'), 'static') apps = [ ('nagare', static) ] # Initialize the result tuple with the static contents of the framework for app_name in app_names: cfgfile, app, project_name, aconf = util.read_application( app_name, error) if aconf is not None: static = aconf['application']['static'] if os.path.isdir(static): apps.append((aconf['application']['name'], static)) return sorted(apps, key=lambda (url, _): len(url))
def create_rules(app_names, error): """Generate the rewrite rules for the given registered applications In: - ``app_names`` -- list of the applications, read from the command line - ``error`` -- the function to call in case of configuration errors Return: - list of tuples (application, directory of its static contents) """ # If no applications is given on the command line, generate the rules # for all the registered applications if not app_names: app_names = [entry.name for entry in pkg_resources.iter_entry_points('nagare.applications')] package = pkg_resources.Requirement.parse('nagare') static = os.path.join(pkg_resources.resource_filename(package, 'nagare'), 'static') apps = [('nagare', static)] # Initialize the result tuple with the static contents of the framework for app_name in app_names: cfgfile, app, project_name, aconf = util.read_application(app_name, error) if aconf is not None: static = aconf['application']['static'] if os.path.isdir(static): apps.append((aconf['application']['name'], static)) return sorted(apps, key=lambda (url, _): len(url))
def _load_config(self, filepath): _, app, _, conf = read_application(filepath, config_error) spec = ConfigObj({'DEFAULT': {'name': 'eureka'}}) conf = ConfigObj(filepath, configspec=publisher_options_spec, interpolation='Template') conf.merge(spec) return conf
def load_config(filepath): _, app, _, conf = read_application(filepath, ValueError) spec = ConfigObj({'DEFAULT': {'name': 'eureka'}}) conf = ConfigObj(filepath, configspec=publisher_options_spec, interpolation='Template') conf.merge(spec) yield conf
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 load_config(filepath): _, app, _, conf = read_application(filepath, ValueError) spec = ConfigObj({'DEFAULT': {'name': 'eureka'}}) conf = ConfigObj( filepath, configspec=publisher_options_spec, interpolation='Template' ) conf.merge(spec) yield conf
def _load_config(self, filepath): _, app, _, conf = read_application(filepath, config_error) spec = ConfigObj({'DEFAULT': {'name': 'eureka'}}) conf = ConfigObj( filepath, configspec=publisher_options_spec, interpolation='Template' ) conf.merge(spec) return conf
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 run(parser, options, args): application = 'kansha' (cfgfile, app, dist, conf) = util.read_application(application, parser.error) infile = open(cfgfile) outfile = open('kansha.cfg', 'w') outfile.write('datadir = "/path/to/folder"\n\n') for line in infile: oline = line.replace('$root/data', '$datadir') outfile.write(oline) infile.close() outfile.close()
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 _set_sqlalchemy_uri(cfg, application, error): aconf = util.read_application(application, error)[-1] cfg.set_main_option('sqlalchemy.url', aconf['database']['uri'])
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)