=============================
Sites and Local Site Managers
=============================

This chapter is an introduction of the location-based component
architecture. This code uses the registration framework introduced in
`registration.txt` and local adapter registries described in
`adapterregistry.txt`.


Creating and Accessing Sites
----------------------------

*Sites* are used to provide custom component setups for parts of your
application or Web site. Every folder,

  >>> from zope.app.folder import folder
  >>> myfolder = folder.rootFolder()

has the potential to become a site

  >>> from zope.app.component import interfaces
  >>> interfaces.IPossibleSite.providedBy(myfolder)
  True

but is not yet one:

  >>> interfaces.ISite.providedBy(myfolder)
  False

If you would like your custom content component to be able to become a site,
you can use the `SiteManagerContainer` mix-in class:

  >>> from zope.app.component import site
  >>> class MyContentComponent(site.SiteManagerContainer):
  ...     pass

  >>> myContent = MyContentComponent()
  >>> interfaces.IPossibleSite.providedBy(myContent)
  True
  >>> interfaces.ISite.providedBy(myContent)
  False

To convert a possible site to a real site, we have to provide a site manager:

  >>> sm = site.LocalSiteManager(myfolder)
  >>> myfolder.setSiteManager(sm)
  >>> interfaces.ISite.providedBy(myfolder)
  True
  >>> myfolder.getSiteManager() is sm
  True

Note that an event is generated when a local site manager is created:

  >>> from zope.app.event.tests.placelesssetup import getEvents
  >>> from zope.app.component.interfaces import INewLocalSite
  >>> [event] = getEvents(INewLocalSite)
  >>> event.manager is sm
  True

If one tries to set a bogus site manager, a `ValueError` will be raised:

   >>> myfolder2 = folder.Folder()
   >>> myfolder2.setSiteManager(object)
   Traceback (most recent call last):
   ...
   ValueError: setSiteManager requires an ISiteManager

Also, if the possible site has been changed to a site already, a `TypeError`
is raised, when one attempts to add a new site manager:

  >>> myfolder.setSiteManager(site.LocalSiteManager(myfolder))
  Traceback (most recent call last):
  ...
  TypeError: Already a site

There is also an adapter you can use to get the next site manager from any
location:

  >>> myfolder['mysubfolder'] = folder.Folder()
  >>> import zope.component
  >>> zope.component.interfaces.ISiteManager(myfolder['mysubfolder']) is sm
  True

If the location passed is a site, the site manager of that site is returned:

  >>> zope.component.interfaces.ISiteManager(myfolder) is sm
  True

During traversal, 

  >>> from zope.app import publication
  >>> request = object()
  >>> ev = publication.interfaces.BeforeTraverseEvent(myfolder, request)
  >>> site.threadSiteSubscriber(myfolder, ev)

the nearest site is also recorded in a thread-global variable:

  >>> from zope.app.component import hooks
  >>> hooks.getSite() is myfolder
  True

After a request is completed, the site setting is cleared again:

  >>> ev = publication.interfaces.EndRequestEvent(myfolder, request)
  >>> site.clearThreadSiteSubscriber(ev)
  >>> hooks.getSite() is None
  True


Using the Site Manager
----------------------

A site manager contains several *site management folders*, which are used to
logically organize the software. When a site manager is initialized, a default
site management folder is created:

  >>> sm = myfolder.getSiteManager()
  >>> default = sm['default']
  >>> default.__class__
  <class 'zope.app.component.site.SiteManagementFolder'>

You can easily create a new site management folder:

  >>> sm['mySMF'] = site.SiteManagementFolder()
  >>> sm['mySMF'].__class__
  <class 'zope.app.component.site.SiteManagementFolder'>

Once you have your site management folder -- let's use the default one -- we
can register some components. Let's start with a utility

  >>> import zope.interface
  >>> class IMyUtility(zope.interface.Interface):
  ...     pass

  >>> import persistent
  >>> from zope.app.container.contained import Contained
  >>> class MyUtility(persistent.Persistent, Contained):
  ...     zope.interface.implements(IMyUtility,
  ...                               interfaces.ILocalUtility)
  ...     def __init__(self, title):
  ...         self.title = title
  ...     def __repr__(self):
  ...         return "%s('%s')" %(self.__class__.__name__, self.title)

Now we can create an instance of our utility and put it in the site
management folder:

  >>> myutil = MyUtility('My custom utility')
  >>> default['myutil'] = myutil

Then we have to create a registration for the utility and activate it:

  >>> reg = site.UtilityRegistration('u1', IMyUtility, myutil)
  >>> default.registrationManager.addRegistration(reg)
  'UtilityRegistration'
  >>> reg.status = interfaces.registration.ActiveStatus

Note that you can only change the status *after* you have added the
registration to the registration manager, since registration component uses
its location to determine the correct registry to add the component to.

Now we can ask the site manager for the utility:

  >>> sm.queryUtility(IMyUtility, 'u1')
  MyUtility('My custom utility')

Of course, the local site manager has also access to the global component
registrations:

  >>> gutil = MyUtility('Global Utility')
  >>> from zope.app import zapi
  >>> gsm = zapi.getGlobalSiteManager()
  >>> gsm.provideUtility(IMyUtility, gutil, 'gutil')
  
  >>> sm.queryUtility(IMyUtility, 'gutil')
  MyUtility('Global Utility')

Next let's see whether we can also successfully register an adapter as
well. Here the adpater will provide the size of a file:

  >>> class IFile(zope.interface.Interface):
  ...     pass

  >>> class ISized(zope.interface.Interface):
  ...     pass

  >>> class File(object):
  ...     zope.interface.implements(IFile)

  >>> class FileSize(object):
  ...     zope.interface.implements(ISized)
  ...     def __init__(self, context):
  ...         self.context = context

We place the adapter in a particular module, so that adapter registration will
be able to look it up by name.

  >>> import sys
  >>> sys.modules['zope.app.component.tests'].FileSize = FileSize

Now that we the adapter we need to register it:

  >>> areg = site.AdapterRegistration(IFile, ISized, 
  ...                                 'zope.app.component.tests.FileSize')
  >>> default.registrationManager.addRegistration(areg)
  'AdapterRegistration'
  >>> areg.status = interfaces.registration.ActiveStatus

Finally, we can get the adapter for a file:

  >>> file = File()
  >>> size = sm.queryAdapter(file, ISized, name='')
  >>> size.__class__
  <class 'FileSize'>
  >>> size.context is file
  True

By the way, once you set a site 

  >>> hooks.setSite(myfolder)

you can simply use the ZAPI's `getSiteManager()` method to get the nearest
site manager:

  >>> zapi.getSiteManager() is sm
  True

This also means that you can simply use ZAPI to look up your utility

  >>> zapi.getUtility(IMyUtility, 'gutil')
  MyUtility('Global Utility')

or the adapter via the interface's `__call__` method:

  >>> size = ISized(file)
  >>> size.__class__
  <class 'FileSize'>
  >>> size.context is file
  True


Multiple Sites
--------------

Until now we have only dealt with one local and the global site. But things
really become interesting, once we have multiple sites. We can override other
local configuration. 

Let's now create a new folder called `folder11`, add it to `myfolder` and make
it a site:

  >>> myfolder11 = folder.Folder()
  >>> myfolder['myfolder11'] = myfolder11
  >>> myfolder11.setSiteManager(site.LocalSiteManager(myfolder11))
  >>> sm11 = myfolder11.getSiteManager()

If we ask the second site manager for its next, we get

  >>> sm11.next is sm
  True

and the first site manager should have the folling sub manager:

  >>> sm.subs == (sm11,)
  True

If we now register a second utility with the same name and interface with the
new site manager folder,

  >>> default11 = sm11['default']
  >>> myutil11 = MyUtility('Utility, uno & uno')
  >>> default11['myutil'] = myutil11

  >>> reg11 = site.UtilityRegistration('u1', IMyUtility, myutil11)
  >>> default11.registrationManager.addRegistration(reg11)
  'UtilityRegistration'
  >>> reg11.status = interfaces.registration.ActiveStatus

then it will will be available in the second site manager

  >>> sm11.queryUtility(IMyUtility, 'u1')
  MyUtility('Utility, uno & uno')

but not in the first one:

  >>> sm.queryUtility(IMyUtility, 'u1')
  MyUtility('My custom utility')

It is also interesting to look at the use cases of moving and copying a
site. To do that we create a second root folder and make it a site, so that
site hierarchy is as follows:

::

           _____ global site _____
          /                       \
      myfolder1                myfolder2
          |
      myfolder11


  >>> myfolder2 = folder.rootFolder()
  >>> myfolder2.setSiteManager(site.LocalSiteManager(myfolder2))

Before we can move or copy sites, we need to register two event subscribers
that manage the wiring of site managers after moving or copying:

  >>> from zope.app import container
  >>> gsm.subscribe((interfaces.ISite, container.interfaces.IObjectMovedEvent),
  ...               None, site.changeSiteConfigurationAfterMove) 

We only have to register one event listener, since the copy action causes an
`IObjectAddedEvent` to be created, which is just a special type of
`IObjectMovedEvent`.

First, make sure that everything is setup correctly in the first place:

  >>> myfolder11.getSiteManager().next is myfolder.getSiteManager()
  True
  >>> myfolder.getSiteManager().subs[0] is myfolder11.getSiteManager()
  True
  >>> myfolder2.getSiteManager().subs
  ()

Let's now move `myfolder11` from `myfolder` to `myfolder2`:

  >>> myfolder2['myfolder21'] = myfolder11
  >>> del myfolder['myfolder11']

Now the next site manager for `myfolder11`'s site manager should have changed:

  >>> myfolder21 = myfolder11
  >>> myfolder21.getSiteManager().next is myfolder2.getSiteManager()
  True
  >>> myfolder2.getSiteManager().subs[0] is myfolder21.getSiteManager()
  True
  >>> myfolder.getSiteManager().subs
  ()

Finally, we make a copy of `myfolder21` and add it as `myfolder11` to
`myfolder`:

  # Make sure that our interfaces and classes are picklable.

  >>> sys.modules['zope.app.component.tests'].IMyUtility = IMyUtility
  >>> IMyUtility.__module__ = 'zope.app.component.tests'
  >>> sys.modules['zope.app.component.tests'].MyUtility = MyUtility
  >>> MyUtility.__module__ = 'zope.app.component.tests'

  >>> from zope.app.location.pickling import locationCopy
  >>> myfolder['myfolder11'] = locationCopy(myfolder2['myfolder21'])

  >>> myfolder11 = myfolder['myfolder11']
  >>> myfolder11.getSiteManager().next is myfolder.getSiteManager()
  True
  >>> myfolder.getSiteManager().subs[0] is myfolder11.getSiteManager()
  True
  >>> myfolder2.getSiteManager().subs[0] is myfolder21.getSiteManager()
  True
