Python hooks.setSite函数代码示例

def upgrade_2001(context): # pragma: no cover
    """
    """
    site = getToolByName(context, 'portal_url').getPortalObject()
    portal_setup = site.portal_setup
    log = logging.getLogger(
        'collective.cron.upgrade.2001')
    try:
        from plone.app.async.interfaces import IAsyncDatabase
        from plone.app.async.service import AsyncService
    except:
        return
    service = AsyncService()
    db = service._db = getUtility(IAsyncDatabase)
    asyncfs = db.databases.get(db.database_name)
    itransaction = Zope2.zpublisher_transactions_manager
    # see plone.app.async.service.AsyncService.getQueues
    try:
        service._conn = asyncfs.open()
        service._conn.onCloseCallback(service.__init__)
        queues = service.getQueues()
        queue = queues['']
        s = getMultiAdapter((site, queue), i.ICrontabMarker)
        for idx, item in enumerate(s.annotations['plone'][:]):
            if isinstance(item, tuple):
                s.annotations['plone'][idx] = item[1]
        itransaction.commit()
    finally:
        asyncfs.close()
    setSite(site)
    log.info('upgrade runned')

    def setUp(self):
        if not os.path.exists(self.dbDir):
            os.mkdir(self.dbDir)
        filename = os.path.join(self.dbDir, 'TestData.fs')
        fsetup = functional.FunctionalTestSetup(self.config_file)
        self.original = fsetup.base_storage
        if not os.path.exists(filename):

            # Generate a new database from scratch and fill it
            db = database(filename)
            connection = db.open()
            root = connection.root()
            app = root[ZopePublication.root_name]
            # store the site, because the connection gets closed
            site = hooks.getSite()
            self.setUpApplication(app)
            transaction.commit()
            connection.close()
            db.close()
            hooks.setSite(site)

        # sets up the db stuff normal
        fsetup.setUp()
        # replace the storage with our filestorage
        fsetup.base_storage = FileStorage(filename)
        # override close on this instance, so files dont get closed on
        # setup/teardown of functionsetup
        fsetup.base_storage.close = lambda: None

def _get_site(app, args):
    # Zope.Startup.zopectl.ZopeCmd.run_entrypoint promises to pass the entry
    # point's name as the first argument and any further arguments after that,
    # but that does not work with plone.recipe.zope2instance. Using positional
    # arguments therefore is unreliable - resolve to using a flag.
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '--plonesite',
        help='Name of the Plone site',
        default=None
    )
    namespace, unused = parser.parse_known_args(args)
    name = namespace.plonesite
    if name is not None:
        if name not in app:
            logger.error("Specified site '%s' not found in database." % name)
            sys.exit(1)
    else:
        from Products.CMFPlone.Portal import PloneSite
        for k, v in app.items():
            if isinstance(v, PloneSite):
                name = k
                break
    if not name:
        logger.error("No Plone site found in database root.")
        sys.exit(1)
    site = getattr(app, name)
    setHooks()
    setSite(site)
    return site

 def setUp(self):
     portal = self.layer['portal']
     setSite(portal)
     self.portal = portal
     self.st = getattr(self.portal, 'portal_setup')
     self.base_path = os.path.dirname(i18n.__file__)
     self.setUpUser()

def silva_session_arg_generator(parent):
    root, options = parent.next()

    if not hasattr(options, 'paths') or not len(options.paths):
        fail(u"specifiy at least one Silva root path")

    for path in options.paths:
        try:
            silva = root.unrestrictedTraverse(path)
        except KeyError:
            fail("%s is not a valid Zope path" % path)
        if not IRoot.providedBy(silva):
            fail("%s is not a valid Silva root" % path)
        if ISite.providedBy(silva):
            setSite(silva)
        else:
            setSite(None)
        setHooks()

        if hasattr(options, 'username') and options.username:
            user = zope_find_user(silva, options.username)
            newSecurityManager(None, user)

        yield silva, options

    try:
        parent.next()
    except StopIteration:
        pass
    else:
        fail(u"internal error")

 def setUp(self):
     portal = self.layer['portal']
     setSite(portal)
     self.portal = portal
     self.qi = getattr(self.portal, 'portal_quickinstaller')
     self.st = getattr(self.portal, 'portal_setup')
     self.setUpUser()

 def setUp(self):
     zope.app.appsetup.product.setProductConfigurations(self.conf)
     zope.app.wsgi.testlayer.BrowserLayer.setUp(self)
     root = self.getRootFolder()
     root['app'] = Uvcsite()
     setSite(root['app'])
     transaction.commit()

 def wrapped_func(*args, **kw):
     sm, site = getSecurityManager(), getSite()
     try:
         return func(*args, **kw)
     finally:
         setSecurityManager(sm)
         setSite(site)

 def setUp(self):
     portal = self.layer['portal']
     self.portal = portal
     self.request = self.layer['request']
     setRoles(portal, TEST_USER_ID, ['Manager'])
     setHooks()
     setSite(portal)

    def test_UnIndex(self):
        """ Setup a catalog deeper within the containment hierarchy
        and call the updateIndexes method. The indexed objects should should
        be restricted to the sublocations.
        """
        from zope.catalog.catalog import indexDocSubscriber
        from zope.catalog.catalog import unindexDocSubscriber
        from zope.container.contained import ObjectAddedEvent
        from zope.container.contained import ObjectRemovedEvent

        ob = Stub()
        self.subfolder['ob'] = ob

        id = self.utility.register(ob)

        setSite(self.subfolder)
        res = self.cat.searchResults(name='ob')
        self.assertEqual(len(res), 0)

        setSite(None)
        indexDocSubscriber(ObjectAddedEvent(ob))

        setSite(self.subfolder)
        res = self.cat.searchResults(name='ob')
        self.assertEqual(len(res), 1)

        setSite(None)
        unindexDocSubscriber(ObjectRemovedEvent(ob))

        setSite(self.subfolder)
        res = self.cat.searchResults(name='ob')
        self.assertEqual(len(res), 0)

def run_ddl_as_script():
    parser = setup_parser()
    options, args = parser.parse_args()

    if len(args) != 1:
        parser.print_help()
        sys.exit(1)
        return

    instance_path = args[0]

    global app

    # Enable Faux HTTP request object
    app = spoof_request(app)

    # Get Plone site object from Zope application server root
    site = app.unrestrictedTraverse(instance_path)
    setHooks()
    setSite(site)
    site.setupCurrentSkin(app.REQUEST)

    # Load portal types with enabled IMirroredContent behavior
    loader.load_models(site)

    if options.drop:
        schema.metadata.drop_all()
    if not options.no_create:
        schema.metadata.create_all()

 def afterSetUp(self):
     self.loginAsPortalOwner()
     setSite(self.portal)
     stool = self.portal.portal_setup
     expected_export = stool.runAllExportSteps()
     self.expected = TarballImportContext(stool, expected_export['tarball'])
     setSite(None)

def check_root_site_manager(tool):
    """2.0.x to 2.1.0 upgrade step checker
    """
    portal = aq_parent(aq_inner(tool))
    try:
        # We have to call setSite to make sure we have a site with a proper
        # acquisition context.
        setSite(portal)
        sm = portal.getSiteManager()
        if sm.utilities.LookupClass != FiveVerifyingAdapterLookup:
            return True
    except ComponentLookupError:
        return True

    for tool_interface in _BAD_UTILITIES:
        try:
            iface = resolve(tool_interface)
        except ImportError:
            continue

        if sm.queryUtility(iface) is not None:
            return True

    for tool_id, tool_interface in _TOOL_UTILITIES:
        tool_obj = getToolByName(portal, tool_id, default=None)
        try:
            iface = resolve(tool_interface)
        except ImportError:
            continue

        if tool_obj is not None and sm.queryUtility(iface) is None:
            return True

    return False

    def testUpgradeAllProposed(self):
        request = self.app.REQUEST
        oldsite = getattr(self.app, self._SITE_ID)
        stool = oldsite.portal_setup
        profile_id = 'Products.CMFDefault:default'
        upgrades = []
        for upgrade_info in stool.listUpgrades(profile_id):
            if isinstance(upgrade_info, list):
                for info in upgrade_info:
                    if info['proposed']:
                        upgrades.append(info['id'])
                continue
            if upgrade_info['proposed']:
                upgrades.append(upgrade_info['id'])

        request.form['profile_id'] = profile_id
        request.form['upgrades'] = upgrades
        stool.manage_doUpgrades(request)

        self.assertEqual(stool.getLastVersionForProfile(profile_id),
                         ('2', '2'))

        newSecurityManager(None, UnrestrictedUser('god', '', ['Manager'], ''))
        setSite(self.app.site)
        expected_export = self.app.site.portal_setup.runAllExportSteps()
        setSite(oldsite)
        upgraded_export = stool.runAllExportSteps()

        expected = TarballImportContext(stool, expected_export['tarball'])
        upgraded = TarballImportContext(stool, upgraded_export['tarball'])
        diff = stool.compareConfigurations(upgraded, expected)
        self.assertEqual(diff, '', diff)

def enableZope3Site(context):
    portal = getToolByName(context, 'portal_url').getPortalObject()
    if not ISite.providedBy(portal):
        make_objectmanager_site(portal)
        logger.info('Made the portal a Zope3 site.')
    try:
        components = portal.getSiteManager()
    except ComponentLookupError:
        next = find_next_sitemanager(portal)
        if next is None:
            next = base
        name = '/'.join(portal.getPhysicalPath())
        components = PersistentComponents(name, (next,))
        components.__parent__ = portal
        portal.setSiteManager(components)
        logger.info("Site manager '%s' added." % name)
    else:
        if components.utilities.LookupClass != FiveVerifyingAdapterLookup:
            # for CMF 2.1 beta instances
            components.__parent__ = portal
            components.utilities.LookupClass = FiveVerifyingAdapterLookup
            components.utilities._createLookup()
            components.utilities.__parent__ = components
            logger.info('LookupClass replaced.')
    # Make sure to set the new site as the new active one
    setSite(portal)