def installDependencies(self):
'''Zope products are installed in alphabetical order. But here, we need
ZCTextIndex to be installed before our Appy application. So, we cheat
and force Zope to install it now.'''
from OFS.Application import install_product
import Products
install_product(self.app, Products.__path__[1], 'ZCTextIndex', [], {})
def installDependencies(self):
'''Zope products are installed in alphabetical order. But here, we need
ZCTextIndex to be installed before our Appy application. So, we cheat
and force Zope to install it now.'''
from OFS.Application import install_product
import Products
install_product(self.app, Products.__path__[1], 'ZCTextIndex', [], {})
def test_install_product(self):
self.makeProduct(os.path.join(TEMPPRODUCTS, 'abaz'))
f = open(os.path.join(TEMPPRODUCTS, 'abaz', '__init__.py'), 'w')
doneflag = os.path.join(TEMPPRODUCTS, 'abaz', 'doneflag')
f.write(dummy_product_init % doneflag)
f.close()
self.configure(cfg)
from OFS.Application import install_product, get_folder_permissions,\
Application
import Products
from OFS.Folder import Folder
app = getApp()
meta_types = []
install_product(app, TEMPPRODUCTS, 'abaz', meta_types,
get_folder_permissions(), raise_exc=1)
# misc_ dictionary is updated
self.assert_(Application.misc_.__dict__.has_key('abaz'))
# initialize is called
self.assert_(os.path.exists(doneflag))
# Methods installed into folder
self.assert_(hasattr(Folder, 'amethod'))
# permission roles put into folder
self.assert_(hasattr(Folder, 'amethod__roles__'))
# Products.meta_types updated
self.assert_( {'name': 'grabass',
'action': 'manage_addProduct/abaz/amethod',
'product': 'abaz',
'permission': 'aPermission',
'visibility': 'Global',
'interfaces': (),
'instance': None,
'container_filter': None}
in Products.meta_types)
def installProduct(app, productName, quiet=False):
"""Install the Zope 2 product with the given name, so that it will show
up in the Zope 2 control panel and have its ``initialize()`` hook called.
The ``STARTUP`` layer or an equivalent layer must have been loaded first.
If ``quiet`` is False, an error will be logged if the product cannot be
found. By default, the function is silent.
Note that products' ZCML is *not* loaded automatically, even if the
product is in the Products namespace.
"""
import sys
from OFS.Folder import Folder
from OFS.Application import get_folder_permissions, get_products
from OFS.Application import install_product, install_package
from App.class_init import InitializeClass
import Products
found = False
if productName in _INSTALLED_PRODUCTS:
return
if productName.startswith('Products.'):
for priority, name, index, productDir in get_products():
if ('Products.' + name) == productName:
install_product(app, productDir, name, [], get_folder_permissions(), raise_exc=1)
InitializeClass(Folder)
_INSTALLED_PRODUCTS[productName] = (priority, name, index, productDir,)
found = True
break
else:
if HAS_ZOPE213:
packages = tuple(get_packages_to_initialize())
else:
packages = getattr(Products, '_packages_to_initialize', [])
for module, init_func in packages:
if module.__name__ == productName:
install_package(app, module, init_func, raise_exc=1)
if not HAS_ZOPE213:
Products._packages_to_initialize.remove((module, init_func))
_INSTALLED_PRODUCTS[productName] = (module, init_func,)
found = True
break
if not found and not quiet:
sys.stderr.write("Could not install product %s\n" % productName)
sys.stderr.flush()
def _installProduct(name, quiet=0):
'''Installs a Zope product.'''
from AccessControl.class_init import InitializeClass
start = time.time()
meta_types = []
if _patched and not _installedProducts.has_key(name):
for priority, product_name, index, product_dir in get_products():
if product_name == name:
if not quiet: _print('Installing %s ... ' % product_name)
# We want to fail immediately if a product throws an exception
# during install, so we set the raise_exc flag.
install_product(_theApp,
product_dir,
product_name,
meta_types,
get_folder_permissions(),
raise_exc=1)
_installedProducts[product_name] = 1
Products.meta_types = Products.meta_types + tuple(meta_types)
InitializeClass(Folder)
if not quiet: _print('done (%.3fs)\n' % (time.time() - start))
break
else:
if name != 'SomeProduct': # Ignore the skeleton tests :-P
if not quiet: _print('Installing %s ... NOT FOUND\n' % name)
def _install_product(self, name, app):
"""Zope 2 install a given product.
"""
meta_types = []
if name not in self.installed_products:
for priority, product_name, index, product_dir in get_products():
if product_name == name:
install_product(app, product_dir, product_name, meta_types,
get_folder_permissions(), raise_exc=1)
self.installed_products.append(name)
Products.meta_types = Products.meta_types + \
tuple(meta_types)
InitializeClass(Folder) # WTF ?
break
def install_products(app, *prod):
"""auxiliary function to install products *prod* (by names)."""
from OFS.Application import get_folder_permissions, get_products, install_product
folder_permissions = get_folder_permissions()
meta_types=[]
done={}
# work around a Zope bug: "Products.__path__" may contain
# non existing elements
import Products, os.path
Products.__path__ = [p for p in Products.__path__ if os.path.exists(p)]
products = get_products()
for priority, product_name, index, product_dir in products:
if product_name not in prod or product_name in done: continue
done[product_name]=1
install_product(app, product_dir, product_name, meta_types,
folder_permissions, raise_exc=True)
def install_products(app):
# Install a list of products into the basic folder class, so
# that all folders know about top-level objects, aka products
#
from OFS.Application import get_folder_permissions
from OFS.Application import install_product
from OFS.Application import install_package
from OFS.Application import get_packages_to_initialize
from OFS.Application import get_products
from App.config import getConfiguration
import transaction
folder_permissions = get_folder_permissions()
meta_types = []
done = {}
debug_mode = getConfiguration().debug_mode
transaction.get().note('Prior to product installs')
transaction.commit()
products = get_products()
for priority, product_name, index, product_dir in products:
# For each product, we will import it and try to call the
# intialize() method in the product __init__ module. If
# the method doesnt exist, we put the old-style information
# together and do a default initialization.
if product_name in done:
continue
if is_sauna_product(product_dir):
# Will be later loaded by installDeferred()
continue
done[product_name] = 1
install_product(app, product_dir, product_name, meta_types,
folder_permissions, raise_exc=debug_mode)
# Delayed install of packages-as-products
for module, init_func in tuple(get_packages_to_initialize()):
install_package(app, module, init_func, raise_exc=debug_mode)
def installProduct(name, quiet=0):
'''Installs a Zope product.'''
start = time.time()
meta_types = []
if _patched and not _installedProducts.has_key(name):
for priority, product_name, index, product_dir in get_products():
if product_name == name:
if not quiet: _print('Installing %s ... ' % product_name)
# We want to fail immediately if a product throws an exception
# during install, so we set the raise_exc flag.
install_product(_theApp, product_dir, product_name, meta_types,
get_folder_permissions(), raise_exc=1)
_installedProducts[product_name] = 1
Products.meta_types = Products.meta_types + tuple(meta_types)
Globals.default__class_init__(Folder)
if not quiet: _print('done (%.3fs)\n' % (time.time() - start))
break
else:
if name != 'SomeProduct': # Ignore the skeleton tests :-P
if not quiet: _print('Installing %s ... NOT FOUND\n' % name)
def _installProduct(name, quiet=0):
'''Installs a Zope product.'''
from AccessControl.class_init import InitializeClass
start = time.time()
meta_types = []
if _patched and not _installedProducts.has_key(name):
for priority, product_name, index, product_dir in get_products():
if product_name == name:
if not quiet:
_print('Installing %s ... ' % product_name)
install_product(_theApp, product_dir, product_name, meta_types,
get_folder_permissions())
_installedProducts[product_name] = 1
Products.meta_types = Products.meta_types + tuple(meta_types)
InitializeClass(Folder)
if not quiet: _print('done (%.3fs)\n' % (time.time() - start))
break
else:
if name != 'SomeProduct': # Ignore the skeleton tests :-P
if not quiet: _print('Installing %s ... NOT FOUND\n' % name)
def install_products(app, *prod):
"""auxiliary function to install products *prod* (by names)."""
from OFS.Application import get_folder_permissions, get_products, install_product
folder_permissions = get_folder_permissions()
meta_types = []
done = {}
# work around a Zope bug: "Products.__path__" may contain
# non existing elements
import Products, os.path
Products.__path__ = [p for p in Products.__path__ if os.path.exists(p)]
products = get_products()
for priority, product_name, index, product_dir in products:
if product_name not in prod or product_name in done: continue
done[product_name] = 1
install_product(app,
product_dir,
product_name,
meta_types,
folder_permissions,
raise_exc=True)
def _installProduct(name, quiet=0):
'''Installs a Zope product.'''
from AccessControl.class_init import InitializeClass
start = time.time()
meta_types = []
if _patched and name not in _installedProducts:
for priority, product_name, index, product_dir in get_products():
if product_name == name:
if not quiet:
_print('Installing %s ... ' % product_name)
install_product(_theApp, product_dir, product_name, meta_types,
get_folder_permissions())
_installedProducts[product_name] = 1
Products.meta_types = Products.meta_types + tuple(meta_types)
InitializeClass(Folder)
if not quiet:
_print('done (%.3fs)\n' % (time.time() - start))
break
else:
if name != 'SomeProduct': # Ignore the skeleton tests :-P
if not quiet:
_print('Installing %s ... NOT FOUND\n' % name)
def test_install_product(self):
self.makeProduct(os.path.join(TEMPPRODUCTS, 'abaz'))
f = open(os.path.join(TEMPPRODUCTS, 'abaz', '__init__.py'), 'w')
doneflag = os.path.join(TEMPPRODUCTS, 'abaz', 'doneflag')
f.write(dummy_product_init % doneflag)
f.close()
self.configure(cfg)
from OFS.Application import install_product, get_folder_permissions,\
Application
import Products
from OFS.Folder import Folder
app = getApp()
meta_types = []
install_product(app,
TEMPPRODUCTS,
'abaz',
meta_types,
get_folder_permissions(),
raise_exc=1)
# misc_ dictionary is updated
self.assert_(Application.misc_.__dict__.has_key('abaz'))
# initialize is called
self.assert_(os.path.exists(doneflag))
# Methods installed into folder
self.assert_(hasattr(Folder, 'amethod'))
# permission roles put into folder
self.assert_(hasattr(Folder, 'amethod__roles__'))
# Products.meta_types updated
self.assert_({
'name': 'grabass',
'action': 'manage_addProduct/abaz/amethod',
'product': 'abaz',
'permission': 'aPermission',
'visibility': 'Global',
'interfaces': (),
'instance': None,
'container_filter': None
} in Products.meta_types)
def installProduct(app, productName, quiet=False, multiinit=False):
"""Install the Zope 2 product with the given name, so that it will show
up in the Zope 2 control panel and have its ``initialize()`` hook called.
The ``STARTUP`` layer or an equivalent layer must have been loaded first.
If ``quiet`` is False, an error will be logged if the product cannot be
found. By default, the function is silent.
Note that products' ZCML is *not* loaded automatically, even if the
product is in the Products namespace.
"""
from App.class_init import InitializeClass
from OFS.Application import get_folder_permissions
from OFS.Application import get_products
from OFS.Application import install_package
from OFS.Application import install_product
from OFS.Folder import Folder
import Products
import sys
found = False
if productName in _INSTALLED_PRODUCTS:
return
if productName.startswith('Products.'):
for priority, name, index, productDir in get_products():
if ('Products.' + name) == productName:
install_product(app,
productDir,
name, [],
get_folder_permissions(),
raise_exc=1)
InitializeClass(Folder)
_INSTALLED_PRODUCTS[productName] = (
priority,
name,
index,
productDir,
)
found = True
break
else:
if HAS_ZOPE213:
packages = tuple(get_packages_to_initialize())
else:
packages = getattr(Products, '_packages_to_initialize', [])
for module, init_func in packages:
if module.__name__ == productName:
install_package(app, module, init_func, raise_exc=1)
if not HAS_ZOPE213:
Products._packages_to_initialize.remove(
(module, init_func))
_INSTALLED_PRODUCTS[productName] = (
module,
init_func,
)
found = True
if not multiinit:
break
if not found and not quiet:
sys.stderr.write("Could not install product %s\n" % productName)
sys.stderr.flush()
