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')