def config(configfile, schemafile=None, features=()): # Load the configuration schema if schemafile is None: schemafile = os.path.join( os.path.dirname(appsetup.__file__), 'schema', 'schema.xml') # Let's support both, an opened file and path if isinstance(schemafile, basestring): schema = ZConfig.loadSchema(schemafile) else: schema = ZConfig.loadSchemaFile(schemafile) # Load the configuration file # Let's support both, an opened file and path try: if isinstance(configfile, basestring): options, handlers = ZConfig.loadConfig(schema, configfile) else: options, handlers = ZConfig.loadConfigFile(schema, configfile) except ZConfig.ConfigurationError as msg: sys.stderr.write("Error: %s\n" % str(msg)) sys.exit(2) # Insert all specified Python paths if options.path: sys.path[:0] = [os.path.abspath(p) for p in options.path] # Parse product configs zope.app.appsetup.product.setProductConfigurations( options.product_config) # Setup the event log options.eventlog() # Setup other defined loggers for logger in options.loggers: logger() # Insert the devmode feature, if turned on if options.devmode: features += ('devmode',) logging.warning("Developer mode is enabled: this is a security risk " "and should NOT be enabled on production servers. Developer mode " "can usually be turned off by setting the `devmode` option to " "`off` or by removing it from the instance configuration file " "completely.") # Execute the ZCML configuration. appsetup.config(options.site_definition, features=features) # Connect to and open the database, notify subscribers. db = appsetup.multi_database(options.databases)[0][0] notify(zope.processlifetime.DatabaseOpened(db)) return db
def config(configfile, schemafile=None, features=()): # Load the configuration schema if schemafile is None: schemafile = os.path.join(os.path.dirname(appsetup.__file__), 'schema', 'schema.xml') # Let's support both, an opened file and path if isinstance(schemafile, basestring): schema = ZConfig.loadSchema(schemafile) else: schema = ZConfig.loadSchemaFile(schemafile) # Load the configuration file # Let's support both, an opened file and path try: if isinstance(configfile, basestring): options, handlers = ZConfig.loadConfig(schema, configfile) else: options, handlers = ZConfig.loadConfigFile(schema, configfile) except ZConfig.ConfigurationError as msg: sys.stderr.write("Error: %s\n" % str(msg)) sys.exit(2) # Insert all specified Python paths if options.path: sys.path[:0] = [os.path.abspath(p) for p in options.path] # Parse product configs zope.app.appsetup.product.setProductConfigurations(options.product_config) # Setup the event log options.eventlog() # Setup other defined loggers for logger in options.loggers: logger() # Insert the devmode feature, if turned on if options.devmode: features += ('devmode', ) logging.warning( "Developer mode is enabled: this is a security risk " "and should NOT be enabled on production servers. Developer mode " "can usually be turned off by setting the `devmode` option to " "`off` or by removing it from the instance configuration file " "completely.") # Execute the ZCML configuration. appsetup.config(options.site_definition, features=features) # Connect to and open the database, notify subscribers. db = appsetup.multi_database(options.databases)[0][0] notify(zope.processlifetime.DatabaseOpened(db)) return db
def setUp(self): """Prepares for a functional test case.""" # Tear down the old demo storages (if any) and create fresh ones abort() self.dbstack.append((self.db, self.connection)) self.connection = None zope.app.appsetup.product.setProductConfigurations( self.local_product_config) self.db = self.app.db = multi_database( DerivedDatabaseFactory(name, self._base_storages) for name in self._database_names)[0][0]
def database_factory(global_conf, file_storage=None, db_definition=None): if file_storage is not None and db_definition is not None: raise TypeError("You may only provide a 'file_storage' or a " "'db_definition' setting, not both.") if file_storage is not None: filename = os.path.join(global_conf['here'], file_storage) db = zope.app.appsetup.database(filename) elif db_definition is not None: filename = os.path.join(global_conf['here'], db_definition) schema_xml = os.path.join(os.path.dirname(__file__), 'schema.xml') schema = ZConfig.loadSchema(schema_xml) cfgroot, cfghandlers = ZConfig.loadConfig(schema, filename) result, databases = multi_database(cfgroot.databases) db = result[0] zope.event.notify(zope.app.appsetup.DatabaseOpened(db)) else: db = None return db
def application_factory(global_conf, conf='zope.conf'): # load 'zope.conf' configuration schema_xml = os.path.join( os.path.dirname(zope.app.appsetup.__file__), 'schema', 'schema.xml') schema = ZConfig.loadSchema(schema_xml) options, handlers = ZConfig.loadConfig( schema, os.path.join(global_conf['here'], conf)) if options.path: sys.path[0:0] = [os.path.abspath(p) for p in options.path] options.eventlog() # load ZCML configuration features = () if options.devmode: features += ('devmode',) zope.app.appsetup.config(options.site_definition, features) # notify of ZODB database opening db = multi_database(options.databases)[0][0] zope.event.notify(DatabaseOpened(db)) zope.event.notify(ProcessStarting()) return WSGIPublisherApplication(db)
if isinstance(configfile, basestring): options, handlers = ZConfig.loadConfig(schema, configfile) else: options, handlers = ZConfig.loadConfigFile(schema, configfile) except ZConfig.ConfigurationError, msg: sys.stderr.write("Error: %s\n" % str(msg)) sys.exit(2) # Insert all specified Python paths if options.path: sys.path[:0] = [os.path.abspath(p) for p in options.path] # Setup the event log options.eventlog() # Insert the devmode feature, if turned on if options.devmode: features += ('devmode',) # Configure the application appsetup.config(options.site_definition, features=features) # Connect to and open the database db = appsetup.multi_database(options.databases)[0][0] # Send out an event that the database has been opened notify(appsetup.interfaces.DatabaseOpened(db)) # Create the WSGI application return WSGIPublisherApplication(db, requestFactory)
def __init__(self, config_file=None, database_names=None, product_config=None): """Initializes Zope 3 framework. Creates a volatile memory storage. Parses Zope3 configuration files. """ self.__dict__ = self.__shared_state if database_names is not None: database_names = tuple(database_names) if not self._init: # Make sure unit tests are cleaned up zope.app.testing.setup.placefulSetUp() zope.app.testing.setup.placefulTearDown() if not config_file: config_file = 'ftesting.zcml' if database_names is None: database_names = ('unnamed',) self.log = StringIO() # Make it silent but keep the log available for debugging logging.root.addHandler(logging.StreamHandler(self.log)) self.old_product_config = copy.deepcopy( zope.app.appsetup.product.saveConfiguration()) configs = [] if product_config: configs = zope.app.appsetup.product.loadConfiguration( StringIO(product_config)) configs = [ zope.app.appsetup.product.FauxConfiguration(name, values) for name, values in configs.items() ] self.local_product_config = configs zope.app.appsetup.product.setProductConfigurations(configs) self._base_storages = {} self.db = multi_database( BaseDatabaseFactory(name, self._base_storages) for name in database_names )[0][0] # This handles anything added by generations or other bootstrap # subscribers. commit() self.dbstack = [] self.app = Debugger(self.db, config_file) self.connection = None self._config_file = config_file self._product_config = product_config self._database_names = database_names self._init = True # Make a local grant for the test user setup = component.queryUtility(IManagerSetup) if setup is not None: setup.setUpManager() FunctionalTestSetup().connection = None elif config_file and config_file != self._config_file: # Running different tests with different configurations is not # supported at the moment raise NotImplementedError('Already configured' ' with a different config file') elif product_config and product_config != self._product_config: raise NotImplementedError('Already configured' ' with different product configuration') elif database_names and database_names != self._database_names: # Running different tests with different configurations is not # supported at the moment raise NotImplementedError('Already configured' ' with different database names')