History for MedusaRequestLifeCycle

??changed:
-
Creation of ZRendezvous threads

    ZRendezvous is a class which spawns off multiple threads to handle Zope requests ::
    
       z2.setNumberOfThreads(NUMBER_OF_THREADS)
       ZServer.PubCore._n = NUMBER_OF_THREADS
       def PubCore.handle():
           _handle = ZRendezvous.ZRendevous(_n)
      
    initializes ZRendevous with NUMBER_OF_THREADS.

Creation of a Request object

    Requests are created and enqueued in ZServer.HTTPServer,
    which in turn passes it to ZServer.PubCore.handle. The
    request gets queued up here and gets handled by one of
    the available threads in the thread pool::

       ZServer.HTTPServer.py

          zrequest=HTTPRequest(sin, env, zresponse)

       ZServer.HTTPServer.py 

          zhttp_channel.work calls 

       ZServer.PubCore.handle       

          handle(module_name, request, response)

    PubCore.handle is an alias for ZRendezvous.handle, it doesn't do
    very much except to put the request in a queue ::

      requests.append((name, request, response))

A Zope object is located for the Request and published

    ZServerPublisher is placed in an infinite loop (see ZServerPublisher.__init__)
    and calls accept() which gets another request to publish.

    ZPubliser.Publish.publish_module() obtains the root object 
    of the ZODB using get_module_info(), then traverses the ZODB
    using PATH_INFO, until it arrives at the object to publish::
 
       def ZPublisher.publish(...):

           (bobo_bef..., object, ...)= get_module_info(module_name)

           request['PARENTS']=parents=[object]

           object=request.traverse(path, validated_hook=validated_hook)

       def get_module_info(module_name, ...):

            if hasattr(module,'bobo_application'):
                object=module.bobo_application

Where is bobo_application set

  Refer to Zope/App/startup.py::

    # Set up the "app" object that automagically opens
    # connections
    app = ZODB.ZApplication.ZApplicationWrapper(
        DB, 'Application', OFS.Application.Application, (),
        Globals.VersionNameName)
    Zope.bobo_application = app

  We can see how the connection is opened in 
  ZODB.ZApplication.ZApplicationWrapper::

    def __bobo_traverse__(self, REQUEST=None, name=None):
        :
        :
        conn=db.open(version)
        v=conn.root()[aname]
        return v

  and also here::

    def __call__(self, connection=None):
        db, aname, version_support = self._stuff

        if connection is None:
            connection=db.open()
        elif type(connection) is StringType:
            connection=db.open(connection)

        return connection.root()[aname]

  Point of note

    If you call::

       import Zope
       root = Zope.app()

    You still can close the connection to the database,
    as you haven't completely lost the reference to the 
    connection. ::

       root._p_jar.close()



  So up to this point there are NUMBER_OF_THREADS instances 
  of ZServerPublisher, which in turn ZODB.