def bootstrapSubscriber(ev):
    db, connection, root, portal = getInformationFromEvent(ev)

    if portal is None:
        portal = Portal(title=u'Portal')
        interface.alsoProvides(portal, IContainmentRoot)
        event.notify(ObjectCreatedEvent(portal))
        root[ZopePublication.root_name] = portal
        transaction.commit()

        try:
            reconfigurePortal(portal)

            setSite(portal)
            catalog = component.getUtility(IConfiglet, 'system.catalog').catalog
            catalog.clear()
            catalog.updateIndexes()
            setSite(None)
        except:
            del root[ZopePublication.root_name]
            transaction.commit()
            raise

        transaction.commit()

    connection.close()

    event.notify(DatabaseOpenedWithRoot(db))

def threadSiteSubscriber(event):
    """A subscriber to BeforeTraverseEvent

    Sets the 'site' thread global if the object traversed is a site.
    """
    if interfaces.ISite.providedBy(event.object):
        setSite(event.object)

    def setUp(test):
        functional.FunctionalTestSetup().setUp()

        root = functional.getRootFolder()
        setSite(root)

        # IIntIds
        root['ids'] = IntIds()

        root.getSiteManager().registerUtility(root['ids'], IIntIds)

        # catalog
        root['catalog'] = Catalog()
        root.getSiteManager().registerUtility(root['catalog'], ICatalog)

        # default content
        content = Content1('Content 1')
        event.notify(ObjectCreatedEvent(content))
        IOwnership(content).ownerId = 'zope.user'
        root['content11'] = content

        content = Content1('Content 2')
        event.notify(ObjectCreatedEvent(content))
        IOwnership(content).ownerId = 'zope.user'
        root['content12'] = content

        content = Content2('Content 3')
        event.notify(ObjectCreatedEvent(content))
        IOwnership(content).ownerId = 'zope.user'
        root['content21'] = content

        content = Content2('Content 4')
        event.notify(ObjectCreatedEvent(content))
        IOwnership(content).ownerId = 'zope.user'
        root['content22'] = content

    def setUp(test):
        functional.FunctionalTestSetup().setUp()

        newInteraction()

        root = functional.getRootFolder()
        setSite(root)
        sm = root.getSiteManager()

        # IIntIds
        root['ids'] = IntIds()
        sm.registerUtility(root['ids'], IIntIds)
        root['ids'].register(root)

        # catalog
        root['catalog'] = Catalog()
        sm.registerUtility(root['catalog'], ICatalog)

        # setup default role
        roles = sm.getUtility(IPortalRoles)
        if 'site.member' not in roles:
            role = PortalRole(title = u'Site Member')
            event.notify(ObjectCreatedEvent(role))

            roles['site.member'] = role
            roleId = role.id
            sm.getUtility(IDefaultPortalRole).roles = [role.id]

        endInteraction()

    def test_nestedSitesDontConflictButStillAcquire(self):
        # let's register a dummy utility in the dummy site
        dummy = DummyUtility()
        sm = zapi.getSiteManager()
        sm.registerUtility(IDummyUtility, dummy)

        # let's also create a subsite and make that our site
        manage_addDummySite(self.folder.site, 'subsite')
        enableLocalSiteHook(self.folder.site.subsite)
        setSite(self.folder.site.subsite)

        # we should still be able to lookup the original utility from
        # the site one level above
        self.assertEqual(zapi.getUtility(IDummyUtility), dummy)

        # now we register a dummy utility in the subsite and see that
        # its registration doesn't conflict
        subdummy = DummyUtility()
        sm = zapi.getSiteManager()
        sm.registerUtility(IDummyUtility, subdummy)

        # when we look it up we get the more local one now because the
        # more local one shadows the less local one
        self.assertEqual(zapi.getUtility(IDummyUtility), subdummy)

        # getAllUtilitiesFor gives us both the more local and the less
        # local utility (XXX not sure if this is the right semantics
        # for getAllUtilitiesFor)
        self.assertEqual(sets.Set(zapi.getAllUtilitiesRegisteredFor(IDummyUtility)),
                         sets.Set([subdummy, dummy]))

        # getUtilitiesFor will only find one, because the more local
        # one shadows the less local one
        self.assertEqual(list(zapi.getUtilitiesFor(IDummyUtility)),
                         [('', subdummy)])

def addConfiguredSite(dispatcher, site_id, profile_id, snapshot=True,
                      RESPONSE=None, extension_ids=()):
    """ Add a CMFSite to 'dispatcher', configured according to 'profile_id'.
    """
    site = CMFSite( site_id )
    dispatcher._setObject( site_id, site )
    site = dispatcher._getOb( site_id )
    setSite(site)

    site._setObject(_TOOL_ID, SetupTool(_TOOL_ID))
    setup_tool = getattr(site, _TOOL_ID)

    setup_tool.setImportContext( 'profile-%s' % profile_id )
    setup_tool.runAllImportSteps()
    for extension_id in extension_ids:
        setup_tool.setImportContext( 'profile-%s' % extension_id )
        setup_tool.runAllImportSteps()
    setup_tool.setImportContext( 'profile-%s' % profile_id )

    if snapshot is True:
        setup_tool.createSnapshot( 'initial_configuration' )

    if RESPONSE is not None:
        RESPONSE.redirect( '%s/%s/manage_main?update_menu=1'
                         % (dispatcher.absolute_url(), site_id) )

    def setUp(test):
        functional.FunctionalTestSetup().setUp()

        root = functional.getRootFolder()
        setSite(root)
        setUpCache()

        sm = root.getSiteManager()

        # IIntIds
        root['ids'] = IntIds()
        sm.registerUtility(root['ids'], IIntIds)
        root['ids'].register(root)

        # catalog
        root['catalog'] = Catalog()
        sm.registerUtility(root['catalog'], ICatalog)

        # people
        root['people'] = PersonalSpaceManager()
        sm.registerUtility(root['people'], IPersonalSpaceManager)

        user = sm.getUtility(IAuthentication).getPrincipal('zope.mgr')
        root['people'].assignPersonalSpace(user)

        activity = sm.getUtility(IActivity)
        try:
            activity.remove(activity.records.keys()[0])
        except IndexError:
            pass

    def setUp(test):
        functional.FunctionalTestSetup().setUp()

        root = functional.getRootFolder()
        setSite(root)
        sm = root.getSiteManager()

        # IIntIds
        root['ids'] = IntIds()
        sm.registerUtility(root['ids'], IIntIds)
        root['ids'].register(root)

        # catalog
        root['catalog'] = Catalog()
        sm.registerUtility(root['catalog'], ICatalog)

        # personal space manager
        root['people'] = PersonalSpaceManager()
        sm.registerUtility(root['people'], IPersonalSpaceManager)

        # default content
        content = Content()
        event.notify(ObjectCreatedEvent(content))
        IOwnership(content).ownerId = 'zope.user'
        root['content'] = content

    def test_components_registered_on_add(self):
        portal_type = u"testtype"
        fti = DexterityFTI(portal_type)
        container_dummy = self.create_dummy()
        
        # Mock the lookup of the site and the site manager at the site root
        dummy_site = self.create_dummy()
        self.mock_utility(dummy_site, ISiteRoot)
        
        site_manager_mock = self.mocker.proxy(PersistentComponents(bases=(getGlobalSiteManager(),)))
        getSiteManager_mock = self.mocker.replace('zope.app.component.hooks.getSiteManager')
        self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock)
        
        # We expect that no components are registered , so look for all registrations
        self.expect(site_manager_mock.registerUtility(fti, IDexterityFTI, portal_type, info='plone.dexterity.dynamic')).passthrough()
        self.expect(site_manager_mock.registerUtility(
                    mocker.MATCH(lambda x: isinstance(x, DexterityFactory) and x.portal_type == portal_type), 
                    IFactory, portal_type, info='plone.dexterity.dynamic')).passthrough()

        self.replay()
        
        ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId()))
        
        site_dummy = self.create_dummy(getSiteManager = lambda: site_manager_mock)
        setSite(site_dummy)
        setHooks()
        
        self.assertNotEquals(None, queryUtility(IDexterityFTI, name=portal_type))
        self.assertNotEquals(None, queryUtility(IFactory, name=portal_type))

def importit(app):

    site = app[SITE_ID]
    setSite(site)
    per_folder = 50
    num_folders = 7
    max_depth = 4
    portal_types = ['Document', 'News Item', 'Event']
    data = Data()

    def populate(parent, count=0, depth=0):
        if depth >= max_depth:
            return count
        for fidx in range(num_folders):
            count += 1
            folder = createObject(parent, 'Folder', 'folder%i' % fidx,
                                  check_for_first=True, delete_first=False,
                                  title="Folder %i" % fidx)
            for didx in range(per_folder):
                count += 1
                print 'created ', count
                createObject(folder, random.choice(portal_types), 'page%i' % didx,
                             check_for_first=True, delete_first=False,
                             title="Page %i" % didx, text=data.next())
            count = populate(folder, count, depth + 1)
        print 'commiting'
        transaction.commit()
        app._p_jar.cacheMinimize()
        return count
    populate(site)

    def setUp(test):
        functional.FunctionalTestSetup().setUp()

        root = functional.getRootFolder()
        setSite(root)
        sm = root.getSiteManager()

        # IIntIds
        root['ids'] = IntIds()
        sm.registerUtility(root['ids'], IIntIds)
        root['ids'].register(root)

        # catalog
        root['catalog'] = Catalog()
        sm.registerUtility(root['catalog'], ICatalog)

        # people
        root['people'] = PersonalSpaceManager()
        sm.registerUtility(root['people'], IPersonalSpaceManager)

        user = sm.getUtility(IAuthentication).getPrincipal('zope.mgr')
        root['people'].assignPersonalSpace(user)

        user = sm.getUtility(IAuthentication).getPrincipal('zope.user1')
        root['people'].assignPersonalSpace(user)

        user = sm.getUtility(IAuthentication).getPrincipal('zope.user2')
        root['people'].assignPersonalSpace(user)

def harvest():
    db = component.getUtility(IDatabase)
    conn = db.open()
    root = conn.root().data['Application']

    portal = IPortal(root, None)
    if portal is None:
        # Old instance of zojax where portal is not the root object.
        # We get the first instance of IPortal if it exists.
        for obj in root.values():
            portal = IPortal(obj, None)
            if portal is not None:
                break
    if portal is None:
        conn.close()
        return
    
    setSite(portal)

    catalog = component.getUtility(ICatalogConfiglet, context=portal).catalog
    workspaces = catalog.searchResults(type={'any_of': ('contenttype.rss.workspace',)})
    try:
        for workspace in workspaces:
            if workspace.harvest():
                transaction.commit()
            else:
                transaction.abort()
    except:
        transaction.abort()
        
    conn.close()

    def __init__(self):

        self.instancehome = os.environ.get("INSTANCE_HOME")

        configfile = os.environ.get("CONFIG_FILE")
        if configfile is None and self.instancehome is not None:
            configfile = os.path.join(self.instancehome, "etc", "zope.conf")

        if configfile is None:
            raise RuntimeError("CONFIG_FILE env not set")

        print "CONFIG_FILE=", configfile
        print "INSTANCE_HOME=", self.instancehome

        self.configfile = configfile

        try:
            from Zope2 import configure
        except ImportError:
            from Zope import configure

        configure(configfile)

        try:
            import Zope2
            app = Zope2.app()
        except ImportError:
            import Zope
            app = Zope.app()

        from Testing.makerequest import makerequest
        self.app = makerequest(app)

        try:
            self._make_permissive()
            print "Permissive security installed"
        except:
            print "Permissive security NOT installed"

        self._pwd = self.portal or self.app

        try:
            from zope.component import getSiteManager
            from zope.component import getGlobalSiteManager
            try:
                from zope.app.component.hooks import setSite
            except ImportError:
                from zope.component.hooks import setSite

            if self.portal is not None:
                setSite(self.portal)

                gsm = getGlobalSiteManager()
                sm = getSiteManager()

                if sm is gsm:
                    print "ERROR SETTING SITE!"
        except:
            # XXX: What exceptions is this supposed to catch?
            pass

    def setUp(test):
        functional.FunctionalTestSetup().setUp()

        root = functional.getRootFolder()
        setSite(root)
        setUpCache()

        sm = root.getSiteManager()

        # IIntIds
        root['ids'] = IntIds()
        sm.registerUtility(root['ids'], IIntIds)
        root['ids'].register(root)

        # catalog
        root['catalog'] = Catalog()
        sm.registerUtility(root['catalog'], ICatalog)

        # people
        root['people'] = PersonalSpaceManager()
        sm.registerUtility(root['people'], IPersonalSpaceManager)

        # space
        space = ContentSpace(title=u'Space')
        event.notify(ObjectCreatedEvent(space))
        root['space'] = space
        interface.directlyProvides(root['space'], IDoNotCacheActionsPortlet)

    def migrateToFive15(self):
        all_utilities = self.context.utilities.objectItems()

        self.unmakeSite()
        self.context.manage_delObjects(['utilities'])
        components_view = queryMultiAdapter((self.context, self.request), 
                                            Interface, 'components.html')
        components_view.makeSite()
        setSite(self.context)

        site_manager = getSiteManager()
        for id, utility in all_utilities:
            info = id.split('-')
            if len(info) == 1:
                name = ''
            else:
                name = info[1]
            interface_name = info[0]

            for iface in providedBy(utility):
                if iface.getName() == interface_name:
                    site_manager.registerUtility(utility, iface, name=name)

        return "Migration done!"

        

 def test_components_unregistered_on_delete(self):
     portal_type = u"testtype"
     fti = DexterityFTI(portal_type)
     container_dummy = self.create_dummy()
     
     # Mock the lookup of the site and the site manager at the site root
     dummy_site = self.create_dummy()
     self.mock_utility(dummy_site, ISiteRoot)
     
     site_manager_mock = self.mocker.proxy(PersistentComponents(bases=(getGlobalSiteManager(),)))
     getSiteManager_mock = self.mocker.replace('zope.app.component.hooks.getSiteManager')
     self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock).count(1,None)
     
     # We expect to always be able to unregister without error, even if the
     # components do not exists (as here)
     
     self.expect(site_manager_mock.unregisterUtility(provided=IDexterityFTI, name=portal_type)).passthrough()
     self.expect(site_manager_mock.unregisterUtility(provided=IFactory, name=portal_type)).passthrough()
     
     self.replay()
     
     # First add the components
     ftiAdded(fti, ObjectAddedEvent(fti, container_dummy, fti.getId()))
     
     # Then remove them again
     ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))
     
     site_dummy = self.create_dummy(getSiteManager = lambda: site_manager_mock)
     setSite(site_dummy)
     setHooks()
     
     self.assertEquals(None, queryUtility(IDexterityFTI, name=portal_type))
     self.assertEquals(None, queryUtility(IFactory, name=portal_type))

 def test_getServices(self):
     self.assertEqual(getServices_hook(None), serviceManager)
     self.assertEqual(getServices_hook(self.root), serviceManager)
     self.assertEqual(getServices_hook(self.f1), self.sm1)
     self.assertEqual(getServices_hook(self.f2), self.sm2)
     setSite(self.f2)
     self.assertEqual(getServices_hook(None), self.sm2)

    def test_global_components_not_unregistered_on_delete(self):
        portal_type = u"testtype"
        fti = DexterityFTI(portal_type)
        container_dummy = self.create_dummy()
        
        # Mock the lookup of the site and the site manager at the site root
        dummy_site = self.create_dummy()
        self.mock_utility(dummy_site, ISiteRoot)
        
        site_manager_mock = self.mocker.proxy(PersistentComponents(bases=(getGlobalSiteManager(),)))
        getSiteManager_mock = self.mocker.replace('zope.app.component.hooks.getSiteManager')
        self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock)
        
        # Register FTI utility and factory utility
        
        self.mock_utility(fti, IDexterityFTI, name=portal_type)
        self.mock_utility(DexterityFactory(portal_type), IFactory, name=portal_type)
        
        # We expect to always be able to unregister without error, even if the
        # component exists. The factory is only unregistered if it was registered
        # with info='plone.dexterity.dynamic'.
        
        self.expect(site_manager_mock.unregisterUtility(provided=IDexterityFTI, name=portal_type)).passthrough()
        

        self.replay()
        
        ftiRemoved(fti, ObjectRemovedEvent(fti, container_dummy, fti.getId()))
        
        site_dummy = self.create_dummy(getSiteManager = lambda: site_manager_mock)
        setSite(site_dummy)
        setHooks()
        
        self.assertNotEquals(None, queryUtility(IDexterityFTI, name=portal_type))
        self.assertNotEquals(None, queryUtility(IFactory, name=portal_type))

    def afterSetUp(self):
        setSite(self.app.site)
        newSecurityManager(None, UnrestrictedUser('god', '', ['Manager'], ''))

        # sessioning setup
        sdm = self.app.session_data_manager
        self.app.REQUEST.set_lazy('SESSION', sdm.getSessionData)

    def test_components_reregistered_on_rename(self):
        portal_type = u"testtype"
        fti = DexterityFTI(portal_type)
        container_dummy = self.create_dummy()
        
        # Mock the lookup of the site and the site manager at the site root
        dummy_site = self.create_dummy()
        self.mock_utility(dummy_site, ISiteRoot)
        
        site_manager_mock = self.mocker.proxy(PersistentComponents(bases=(getGlobalSiteManager(),)))
        getSiteManager_mock = self.mocker.replace('zope.app.component.hooks.getSiteManager')
        self.expect(getSiteManager_mock(dummy_site)).result(site_manager_mock).count(1,None)
        
        # First look for unregistration of all local components
        
        self.expect(site_manager_mock.unregisterUtility(provided=IDexterityFTI, name=portal_type)).passthrough()        
        
        # Then look for re-registration of global components
        self.expect(site_manager_mock.registerUtility(fti, IDexterityFTI, portal_type, info='plone.dexterity.dynamic')).passthrough()
        self.expect(site_manager_mock.registerUtility(
                    mocker.MATCH(lambda x: isinstance(x, DexterityFactory) and x.portal_type == portal_type), 
                    IFactory, portal_type, info='plone.dexterity.dynamic')).passthrough()

        self.assertEquals('string:${folder_url}/++add++testtype', fti.add_view_expr)

        self.replay()
        
        ftiRenamed(fti, ObjectMovedEvent(fti, container_dummy, fti.getId(), container_dummy, u"newtype"))
        
        site_dummy = self.create_dummy(getSiteManager = lambda: site_manager_mock)
        setSite(site_dummy)
        setHooks()
        
        self.assertNotEquals(None, queryUtility(IDexterityFTI, name=portal_type))
        self.assertNotEquals(None, queryUtility(IFactory, name=portal_type))