Split ZEO into separate project

setup.py

@@ -20,7 +20,7 @@ to application logic.  ZODB includes features such as a plugable storage
 interface, rich transaction support, and undo.
 """
 
-VERSION = "3.11dev"
+VERSION = "4.0.0dev"
 
 from ez_setup import use_setuptools
 use_setuptools()

src/ZEO/Exceptions.py

-##############################################################################
-#
-# Copyright (c) 2001, 2002 Zope Foundation and Contributors.
-# All Rights Reserved.
-#
-# This software is subject to the provisions of the Zope Public License,
-# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
-# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
-# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
-# FOR A PARTICULAR PURPOSE
-#
-##############################################################################
-"""Exceptions for ZEO."""
-
-from ZODB.POSException import StorageError
-
-class ClientStorageError(StorageError):
-    """An error occurred in the ZEO Client Storage."""
-
-class UnrecognizedResult(ClientStorageError):
-    """A server call returned an unrecognized result."""
-
-class ClientDisconnected(ClientStorageError):
-    """The database storage is disconnected from the storage."""
-
-class AuthError(StorageError):
-    """The client provided invalid authentication credentials."""

src/ZEO/TransactionBuffer.py

-##############################################################################
-#
-# Copyright (c) 2001, 2002 Zope Foundation and Contributors.
-# All Rights Reserved.
-#
-# This software is subject to the provisions of the Zope Public License,
-# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
-# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
-# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
-# FOR A PARTICULAR PURPOSE
-#
-##############################################################################
-"""A TransactionBuffer store transaction updates until commit or abort.
-
-A transaction may generate enough data that it is not practical to
-always hold pending updates in memory.  Instead, a TransactionBuffer
-is used to store the data until a commit or abort.
-"""
-
-# A faster implementation might store trans data in memory until it
-# reaches a certain size.
-
-from threading import Lock
-import os
-import cPickle
-import tempfile
-import ZODB.blob
-
-class TransactionBuffer:
-
-    # Valid call sequences:
-    #
-    #     ((store | invalidate)* begin_iterate next* clear)* close
-    #
-    # get_size can be called any time
-
-    # The TransactionBuffer is used by client storage to hold update
-    # data until the tpc_finish().  It is normally used by a single
-    # thread, because only one thread can be in the two-phase commit
-    # at one time.
-
-    # It is possible, however, for one thread to close the storage
-    # while another thread is in the two-phase commit.  We must use
-    # a lock to guard against this race, because unpredictable things
-    # can happen in Python if one thread closes a file that another
-    # thread is reading.  In a debug build, an assert() can fail.
-
-    # Caution:  If an operation is performed on a closed TransactionBuffer,
-    # it has no effect and does not raise an exception.  The only time
-    # this should occur is when a ClientStorage is closed in one
-    # thread while another thread is in its tpc_finish().  It's not
-    # clear what should happen in this case.  If the tpc_finish()
-    # completes without error, the Connection using it could have
-    # inconsistent data.  This should have minimal effect, though,
-    # because the Connection is connected to a closed storage.
-
-    def __init__(self):
-        self.file = tempfile.TemporaryFile(suffix=".tbuf")
-        self.lock = Lock()
-        self.closed = 0
-        self.count = 0
-        self.size = 0
-        self.blobs = []
-        # It's safe to use a fast pickler because the only objects
-        # stored are builtin types -- strings or None.
-        self.pickler = cPickle.Pickler(self.file, 1)
-        self.pickler.fast = 1
-
-    def close(self):
-        self.clear()
-        self.lock.acquire()
-        try:
-            self.closed = 1
-            try:
-                self.file.close()
-            except OSError:
-                pass
-        finally:
-            self.lock.release()
-
-    def store(self, oid, data):
-        """Store oid, version, data for later retrieval"""
-        self.lock.acquire()
-        try:
-            if self.closed:
-                return
-            self.pickler.dump((oid, data))
-            self.count += 1
-            # Estimate per-record cache size
-            self.size = self.size + (data and len(data) or 0) + 31
-        finally:
-            self.lock.release()
-
-    def storeBlob(self, oid, blobfilename):
-        self.blobs.append((oid, blobfilename))
-
-    def invalidate(self, oid):
-        self.lock.acquire()
-        try:
-            if self.closed:
-                return
-            self.pickler.dump((oid, None))
-            self.count += 1
-        finally:
-            self.lock.release()
-
-    def clear(self):
-        """Mark the buffer as empty"""
-        self.lock.acquire()
-        try:
-            if self.closed:
-                return
-            self.file.seek(0)
-            self.count = 0
-            self.size = 0
-            while self.blobs:
-                oid, blobfilename = self.blobs.pop()
-                if os.path.exists(blobfilename):
-                    ZODB.blob.remove_committed(blobfilename)
-        finally:
-            self.lock.release()
-
-    def __iter__(self):
-        self.lock.acquire()
-        try:
-            if self.closed:
-                return
-            self.file.flush()
-            self.file.seek(0)
-            return TBIterator(self.file, self.count)
-        finally:
-            self.lock.release()
-
-class TBIterator(object):
-
-    def __init__(self, f, count):
-        self.file = f
-        self.count = count
-        self.unpickler = cPickle.Unpickler(f)
-
-    def __iter__(self):
-        return self
-
-    def next(self):
-        """Return next tuple of data or None if EOF"""
-        if self.count == 0:
-            self.file.seek(0)
-            self.size = 0
-            raise StopIteration
-        oid_ver_data = self.unpickler.load()
-        self.count -= 1
-        return oid_ver_data

src/ZEO/__init__.py

-##############################################################################
-#
-# Copyright (c) 2001, 2002 Zope Foundation and Contributors.
-# All Rights Reserved.
-#
-# This software is subject to the provisions of the Zope Public License,
-# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
-# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
-# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
-# FOR A PARTICULAR PURPOSE
-#
-##############################################################################
-"""ZEO -- Zope Enterprise Objects.
-
-See the file README.txt in this directory for an overview.
-
-ZEO is now part of ZODB; ZODB's home on the web is
-
-    http://wiki.zope.org/ZODB
-
-"""
-
-def client(*args, **kw):
-    import ZEO.ClientStorage
-    return ZEO.ClientStorage.ClientStorage(*args, **kw)
-
-def DB(*args, **kw):
-    import ZODB
-    return ZODB.DB(client(*args, **kw))
-
-def connection(*args, **kw):
-    return DB(*args, **kw).open_then_close_db_when_connection_closes()
-
-def server(path=None, blob_dir=None, storage_conf=None, zeo_conf=None,
-           port=None):
-    """Convenience function to start a server for interactive exploration
-
-    This fuction starts a ZEO server, given a storage configuration or
-    a file-storage path and blob directory.  You can also supply a ZEO
-    configuration string or a port.  If neither a ZEO port or
-    configuration is supplied, a port is chosen randomly.
-
-    The server address and a stop function are returned. The address
-    can be passed to ZEO.ClientStorage.ClientStorage or ZEO.DB to
-    create a client to the server. The stop function can be called
-    without arguments to stop the server.
-
-    Arguments:
-
-    path
-       A file-storage path. This argument is ignored if a storage
-       configuration is supplied.
-
-    blob_dir
-       A blob directory path. This argument is ignored if a storage
-       configuration is supplied.
-
-    storage_conf
-       A storage configuration string.  If none is supplied, then at
-       least a file-storage path must be supplied and the storage
-       configuration will be generated from the file-storage path and
-       the blob directory.
-
-    zeo_conf
-       A ZEO server configuration string.
-
-    port
-       If no ZEO configuration is supplied, the one will be computed
-       from the port.  If no port is supplied, one will be chosedn
-       randomly.
-
-    """
-    import os, ZEO.tests.forker
-    if storage_conf is None and path is None:
-        storage_conf = '<mappingstorage>\n</mappingstorage>'
-    if port is None and zeo_conf is None:
-        port = ZEO.tests.forker.get_port()
-
-    addr, admin, pid, config = ZEO.tests.forker.start_zeo_server(
-        storage_conf, zeo_conf, port, keep=True, path=path,
-        blob_dir=blob_dir, suicide=False)
-    os.remove(config)
-    def stop_server():
-        ZEO.tests.forker.shutdown_zeo_server(admin)
-        os.waitpid(pid, 0)
-    return addr, stop_server

src/ZEO/auth/__init__.py

-##############################################################################
-#
-# Copyright (c) 2003 Zope Foundation and Contributors.
-# All Rights Reserved.
-#
-# This software is subject to the provisions of the Zope Public License,
-# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
-# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
-# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
-# FOR A PARTICULAR PURPOSE
-#
-##############################################################################
-
-_auth_modules = {}
-
-def get_module(name):
-    if name == 'sha':
-        from auth_sha import StorageClass, SHAClient, Database
-        return StorageClass, SHAClient, Database
-    elif name == 'digest':
-        from auth_digest import StorageClass, DigestClient, DigestDatabase
-        return StorageClass, DigestClient, DigestDatabase
-    else:
-        return _auth_modules.get(name)
-
-def register_module(name, storage_class, client, db):
-    if _auth_modules.has_key(name):
-        raise TypeError("%s is already registred" % name)
-    _auth_modules[name] = storage_class, client, db

src/ZEO/auth/auth_digest.py

-##############################################################################
-#
-# Copyright (c) 2003 Zope Foundation and Contributors.
-# All Rights Reserved.
-#
-# This software is subject to the provisions of the Zope Public License,
-# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
-# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
-# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
-# FOR A PARTICULAR PURPOSE
-#
-##############################################################################
-"""Digest authentication for ZEO
-
-This authentication mechanism follows the design of HTTP digest
-authentication (RFC 2069).  It is a simple challenge-response protocol
-that does not send passwords in the clear, but does not offer strong
-security.  The RFC discusses many of the limitations of this kind of
-protocol.
-
-Guard the password database as if it contained plaintext passwords.
-It stores the hash of a username and password.  This does not expose
-the plaintext password, but it is sensitive nonetheless.  An attacker
-with the hash can impersonate the real user.  This is a limitation of
-the simple digest scheme.
-
-HTTP is a stateless protocol, and ZEO is a stateful protocol.  The
-security requirements are quite different as a result.  The HTTP
-protocol uses a nonce as a challenge.  The ZEO protocol requires a
-separate session key that is used for message authentication.  We
-generate a second nonce for this purpose; the hash of nonce and
-user/realm/password is used as the session key.
-
-TODO: I'm not sure if this is a sound approach; SRP would be preferred.
-"""
-
-import os
-import random
-import struct
-import time
-
-from ZEO.auth.base import Database, Client
-from ZEO.StorageServer import ZEOStorage
-from ZEO.Exceptions import AuthError
-from ZEO.hash import sha1
-
-def get_random_bytes(n=8):
-    if os.path.exists("/dev/urandom"):
-        f = open("/dev/urandom")
-        s = f.read(n)
-        f.close()
-    else:
-        L = [chr(random.randint(0, 255)) for i in range(n)]
-        s = "".join(L)
-    return s
-
-def hexdigest(s):
-    return sha1(s).hexdigest()
-
-class DigestDatabase(Database):
-    def __init__(self, filename, realm=None):
-        Database.__init__(self, filename, realm)
-
-        # Initialize a key used to build the nonce for a challenge.
-        # We need one key for the lifetime of the server, so it
-        # is convenient to store in on the database.
-        self.noncekey = get_random_bytes(8)
-
-    def _store_password(self, username, password):
-        dig = hexdigest("%s:%s:%s" % (username, self.realm, password))
-        self._users[username] = dig
-
-def session_key(h_up, nonce):
-    # The hash itself is a bit too short to be a session key.
-    # HMAC wants a 64-byte key.  We don't want to use h_up
-    # directly because it would never change over time.  Instead
-    # use the hash plus part of h_up.
-    return sha1("%s:%s" % (h_up, nonce)).digest() + h_up[:44]
-
-class StorageClass(ZEOStorage):
-    def set_database(self, database):
-        assert isinstance(database, DigestDatabase)
-        self.database = database
-        self.noncekey = database.noncekey
-
-    def _get_time(self):
-        # Return a string representing the current time.
-        t = int(time.time())
-        return struct.pack("i", t)
-
-    def _get_nonce(self):
-        # RFC 2069 recommends a nonce of the form
-        # H(client-IP ":" time-stamp ":" private-key)
-        dig = sha1()
-        dig.update(str(self.connection.addr))
-        dig.update(self._get_time())
-        dig.update(self.noncekey)
-        return dig.hexdigest()
-
-    def auth_get_challenge(self):
-        """Return realm, challenge, and nonce."""
-        self._challenge = self._get_nonce()
-        self._key_nonce = self._get_nonce()
-        return self.auth_realm, self._challenge, self._key_nonce
-
-    def auth_response(self, resp):
-        # verify client response
-        user, challenge, response = resp
-
-        # Since zrpc is a stateful protocol, we just store the nonce
-        # we sent to the client.  It will need to generate a new
-        # nonce for a new connection anyway.
-        if self._challenge != challenge:
-            raise ValueError("invalid challenge")
-
-        # lookup user in database
-        h_up = self.database.get_password(user)
-
-        # regeneration resp from user, password, and nonce
-        check = hexdigest("%s:%s" % (h_up, challenge))
-        if check == response:
-            self.connection.setSessionKey(session_key(h_up, self._key_nonce))
-        return self._finish_auth(check == response)
-
-    extensions = [auth_get_challenge, auth_response]
-
-class DigestClient(Client):
-    extensions = ["auth_get_challenge", "auth_response"]
-
-    def start(self, username, realm, password):
-        _realm, challenge, nonce = self.stub.auth_get_challenge()
-        if _realm != realm:
-            raise AuthError("expected realm %r, got realm %r"
-                            % (_realm, realm))
-        h_up = hexdigest("%s:%s:%s" % (username, realm, password))
-
-        resp_dig = hexdigest("%s:%s" % (h_up, challenge))
-        result = self.stub.auth_response((username, challenge, resp_dig))
-        if result:
-            return session_key(h_up, nonce)
-        else:
-            return None

src/ZEO/auth/base.py

-##############################################################################
-#
-# Copyright (c) 2003 Zope Foundation and Contributors.
-# All Rights Reserved.
-#
-# This software is subject to the provisions of the Zope Public License,
-# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
-# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
-# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
-# FOR A PARTICULAR PURPOSE
-#
-##############################################################################
-"""Base classes for defining an authentication protocol.
-
-Database -- abstract base class for password database
-Client -- abstract base class for authentication client
-"""
-
-import os
-from ZEO.hash import sha1
-
-class Client:
-    # Subclass should override to list the names of methods that
-    # will be called on the server.
-    extensions = []
-
-    def __init__(self, stub):
-        self.stub = stub
-        for m in self.extensions:
-            setattr(self.stub, m, self.stub.extensionMethod(m))
-
-def sort(L):
-    """Sort a list in-place and return it."""
-    L.sort()
-    return L
-
-class Database:
-    """Abstracts a password database.
-
-    This class is used both in the authentication process (via
-    get_password()) and by client scripts that manage the password
-    database file.
-
-    The password file is a simple, colon-separated text file mapping
-    usernames to password hashes. The hashes are SHA hex digests
-    produced from the password string.
-    """
-    realm = None
-    def __init__(self, filename, realm=None):
-        """Creates a new Database
-
-        filename: a string containing the full pathname of
-            the password database file. Must be readable by the user
-            running ZEO. Must be writeable by any client script that
-            accesses the database.
-
-        realm: the realm name (a string)
-        """
-        self._users = {}
-        self.filename = filename
-        self.load()
-        if realm:
-            if self.realm and self.realm != realm:
-                raise ValueError("Specified realm %r differs from database "
-                                 "realm %r" % (realm or '', self.realm))
-            else:
-                self.realm = realm
-
-    def save(self, fd=None):
-        filename = self.filename
-
-        if not fd:
-            fd = open(filename, 'w')
-        if self.realm:
-            print >> fd, "realm", self.realm
-
-        for username in sort(self._users.keys()):
-            print >> fd, "%s: %s" % (username, self._users[username])
-
-    def load(self):
-        filename = self.filename
-        if not filename:
-            return
-
-        if not os.path.exists(filename):
-            return
-
-        fd = open(filename)
-        L = fd.readlines()
-
-        if not L:
-            return
-
-        if L[0].startswith("realm "):
-            line = L.pop(0).strip()
-            self.realm = line[len("realm "):]
-
-        for line in L:
-            username, hash = line.strip().split(":", 1)
-            self._users[username] = hash.strip()
-
-    def _store_password(self, username, password):
-        self._users[username] = self.hash(password)
-
-    def get_password(self, username):
-        """Returns password hash for specified username.
-
-        Callers must check for LookupError, which is raised in
-        the case of a non-existent user specified."""
-        if not self._users.has_key(username):
-            raise LookupError("No such user: %s" % username)
-        return self._users[username]
-
-    def hash(self, s):
-        return sha1(s).hexdigest()
-
-    def add_user(self, username, password):
-        if self._users.has_key(username):
-            raise LookupError("User %s already exists" % username)
-        self._store_password(username, password)
-
-    def del_user(self, username):
-        if not self._users.has_key(username):
-            raise LookupError("No such user: %s" % username)
-        del self._users[username]
-
-    def change_password(self, username, password):
-        if not self._users.has_key(username):
-            raise LookupError("No such user: %s" % username)
-        self._store_password(username, password)

src/ZEO/auth/hmac.py

-"""HMAC (Keyed-Hashing for Message Authentication) Python module.
-
-Implements the HMAC algorithm as described by RFC 2104.
-"""
-
-def _strxor(s1, s2):
-    """Utility method. XOR the two strings s1 and s2 (must have same length).
-    """
-    return "".join(map(lambda x, y: chr(ord(x) ^ ord(y)), s1, s2))
-
-# The size of the digests returned by HMAC depends on the underlying
-# hashing module used.
-digest_size = None
-
-class HMAC:
-    """RFC2104 HMAC class.
-
-    This supports the API for Cryptographic Hash Functions (PEP 247).
-    """
-
-    def __init__(self, key, msg = None, digestmod = None):
-        """Create a new HMAC object.
-
-        key:       key for the keyed hash object.
-        msg:       Initial input for the hash, if provided.
-        digestmod: A module supporting PEP 247. Defaults to the md5 module.
-        """
-        if digestmod is None:
-            import md5
-            digestmod = md5
-
-        self.digestmod = digestmod
-        self.outer = digestmod.new()
-        self.inner = digestmod.new()
-        self.digest_size = digestmod.digest_size
-
-        blocksize = 64
-        ipad = "\x36" * blocksize
-        opad = "\x5C" * blocksize
-
-        if len(key) > blocksize:
-            key = digestmod.new(key).digest()
-
-        key = key + chr(0) * (blocksize - len(key))
-        self.outer.update(_strxor(key, opad))
-        self.inner.update(_strxor(key, ipad))
-        if msg is not None:
-            self.update(msg)
-
-##    def clear(self):
-##        raise NotImplementedError("clear() method not available in HMAC.")
-
-    def update(self, msg):
-        """Update this hashing object with the string msg.
-        """
-        self.inner.update(msg)
-
-    def copy(self):
-        """Return a separate copy of this hashing object.
-
-        An update to this copy won't affect the original object.
-        """
-        other = HMAC("")
-        other.digestmod = self.digestmod
-        other.inner = self.inner.copy()
-        other.outer = self.outer.copy()
-        return other
-
-    def digest(self):
-        """Return the hash value of this hashing object.
-
-        This returns a string containing 8-bit data.  The object is
-        not altered in any way by this function; you can continue
-        updating the object after calling this function.
-        """
-        h = self.outer.copy()
-        h.update(self.inner.digest())
-        return h.digest()
-
-    def hexdigest(self):
-        """Like digest(), but returns a string of hexadecimal digits instead.
-        """
-        return "".join([hex(ord(x))[2:].zfill(2)
-                        for x in tuple(self.digest())])
-
-def new(key, msg = None, digestmod = None):
-    """Create a new hashing object and return it.
-
-    key: The starting key for the hash.
-    msg: if available, will immediately be hashed into the object's starting
-    state.
-
-    You can now feed arbitrary strings into the object using its update()
-    method, and can ask for the hash value at any time by calling its digest()
-    method.
-    """
-    return HMAC(key, msg, digestmod)

src/ZEO/component.xml

-<component>
-
-  <sectiontype name="zeo">
-
-    <description>
-      The content of a ZEO section describe operational parameters
-      of a ZEO server except for the storage(s) to be served.
-    </description>
-
-    <key name="address" datatype="socket-binding-address"
-         required="yes">
-      <description>
-        The address at which the server should listen.  This can be in
-        the form 'host:port' to signify a TCP/IP connection or a
-        pathname string to signify a Unix domain socket connection (at
-        least one '/' is required).  A hostname may be a DNS name or a
-        dotted IP address.  If the hostname is omitted, the platform's
-        default behavior is used when binding the listening socket (''
-        is passed to socket.bind() as the hostname portion of the
-        address).
-      </description>
-    </key>
-
-    <key name="read-only" datatype="boolean"
-         required="no"
-         default="false">
-      <description>
-        Flag indicating whether the server should operate in read-only
-        mode.  Defaults to false.  Note that even if the server is
-        operating in writable mode, individual storages may still be
-        read-only.  But if the server is in read-only mode, no write
-        operations are allowed, even if the storages are writable.  Note
-        that pack() is considered a read-only operation.
-      </description>
-    </key>
-
-    <key name="invalidation-queue-size" datatype="integer"
-         required="no"
-         default="100">
-      <description>
-        The storage server keeps a queue of the objects modified by the
-        last N transactions, where N == invalidation_queue_size.  This
-        queue is used to speed client cache verification when a client
-        disconnects for a short period of time.
-      </description>
-    </key>
-
-    <key name="invalidation-age" datatype="float" required="no">
-      <description>
-        The maximum age of a client for which quick-verification
-        invalidations will be provided by iterating over the served
-        storage. This option should only be used if the served storage
-        supports efficient iteration from a starting point near the
-        end of the transaction history (e.g. end of file).
-      </description>
-    </key>
-
-    <key name="monitor-address" datatype="socket-binding-address"
-         required="no">
-      <description>
-        The address at which the monitor server should listen.  If
-        specified, a monitor server is started.  The monitor server
-        provides server statistics in a simple text format.  This can
-        be in the form 'host:port' to signify a TCP/IP connection or a
-        pathname string to signify a Unix domain socket connection (at
-        least one '/' is required).  A hostname may be a DNS name or a
-        dotted IP address.  If the hostname is omitted, the platform's
-        default behavior is used when binding the listening socket (''
-        is passed to socket.bind() as the hostname portion of the
-        address).
-      </description>
-    </key>
-
-    <key name="transaction-timeout" datatype="integer"
-         required="no">
-      <description>
-        The maximum amount of time to wait for a transaction to commit
-        after acquiring the storage lock, specified in seconds.  If the
-        transaction takes too long, the client connection will be closed
-        and the transaction aborted.
-      </description>
-    </key>
-
-    <key name="authentication-protocol" required="no">
-      <description>
-        The name of the protocol used for authentication.  The
-        only protocol provided with ZEO is "digest," but extensions
-        may provide other protocols.
-      </description>
-    </key>
-
-    <key name="authentication-database" required="no">
-      <description>
-        The path of the database containing authentication credentials.
-      </description>
-    </key>
-
-    <key name="authentication-realm" required="no">
-      <description>
-        The authentication realm of the server.  Some authentication
-        schemes use a realm to identify the logical set of usernames
-        that are accepted by this server.
-      </description>
-    </key>
-
-    <key name="pid-filename" datatype="existing-dirpath"
-         required="no">
-      <description>
-        The full path to the file in which to write the ZEO server's Process ID
-        at startup. If omitted, $INSTANCE/var/ZEO.pid is used.
-      </description>
-      <metadefault>$INSTANCE/var/ZEO.pid (or $clienthome/ZEO.pid)</metadefault>
-    </key>
-
-    <!-- DM 2006-06-12: added option -->
-    <key name="drop-cache-rather-verify" datatype="boolean"
-         required="no" default="false">
-       <description>
-         indicates that the cache should be dropped rather than
-	 verified when the verification optimization is not
-	 available (e.g. when the ZEO server restarted).
-       </description>
-    </key>
-
-  </sectiontype>
-
-</component>

src/ZEO/hash.py

-##############################################################################
-#
-# Copyright (c) 2008 Zope Foundation and Contributors.
-# All Rights Reserved.
-#
-# This software is subject to the provisions of the Zope Public License,
-# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
-# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
-# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
-# FOR A PARTICULAR PURPOSE.
-#
-##############################################################################
-
-"""In Python 2.6, the "sha" and "md5" modules have been deprecated
-in favor of using hashlib for both. This class allows for compatibility
-between versions."""
-
-try:
-    import hashlib
-    sha1 = hashlib.sha1
-    new = sha1
-except ImportError:
-    import sha
-    sha1 = sha.new
-    new = sha1
-    digest_size = sha.digest_size

src/ZEO/interfaces.py

-##############################################################################
-#
-# Copyright (c) 2006 Zope Foundation and Contributors.
-# All Rights Reserved.
-#
-# This software is subject to the provisions of the Zope Public License,
-# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
-# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
-# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
-# FOR A PARTICULAR PURPOSE.
-#
-##############################################################################
-
-import zope.interface
-
-class StaleCache(object):
-    """A ZEO cache is stale and requires verification.
-    """
-
-    def __init__(self, storage):
-        self.storage = storage
-
-class IServeable(zope.interface.Interface):
-    """Interface provided by storages that can be served by ZEO
-    """
-
-    def getTid(oid):
-        """The last transaction to change an object
-
-        Return the transaction id of the last transaction that committed a
-        change to an object with the given object id.
-
-        """
-
-    def tpc_transaction():
-        """The current transaction being committed.
-
-        If a storage is participating in a two-phase commit, then
-        return the transaction (object) being committed.  Otherwise
-        return None.
-        """
-
-    def lastInvalidations(size):
-        """Get recent transaction invalidations
-
-        This method is optional and is used to get invalidations
-        performed by the most recent transactions.
-
-        An iterable of up to size entries must be returned, where each
-        entry is a transaction id and a sequence of object-id/empty-string
-        pairs describing the objects written by the
-        transaction, in chronological order.
-        """

src/ZEO/monitor.py

-##############################################################################
-#
-# Copyright (c) 2003 Zope Foundation and Contributors.
-# All Rights Reserved.
-#
-# This software is subject to the provisions of the Zope Public License,
-# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
-# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
-# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
-# FOR A PARTICULAR PURPOSE
-#
-##############################################################################
-"""Monitor behavior of ZEO server and record statistics.
-
-$Id$
-"""
-
-import asyncore
-import socket
-import time
-import logging
-
-zeo_version = 'unknown'
-try:
-    import pkg_resources
-except ImportError:
-    pass
-else:
-    zeo_dist = pkg_resources.working_set.find(
-        pkg_resources.Requirement.parse('ZODB3')
-        )
-    if zeo_dist is not None:
-        zeo_version = zeo_dist.version
-
-class StorageStats:
-    """Per-storage usage statistics."""
-
-    def __init__(self, connections=None):
-        self.connections = connections
-        self.loads = 0
-        self.stores = 0
-        self.commits = 0
-        self.aborts = 0
-        self.active_txns = 0
-        self.verifying_clients = 0
-        self.lock_time = None
-        self.conflicts = 0
-        self.conflicts_resolved = 0
-        self.start = time.ctime()
-
-    @property
-    def clients(self):
-        return len(self.connections)
-
-    def parse(self, s):
-        # parse the dump format
-        lines = s.split("\n")
-        for line in lines:
-            field, value = line.split(":", 1)
-            if field == "Server started":
-                self.start = value
-            elif field == "Clients":
-                # Hack because we use this both on the server and on
-                # the client where there are no connections.
-                self.connections = [0] * int(value)
-            elif field == "Clients verifying":
-                self.verifying_clients = int(value)
-            elif field == "Active transactions":
-                self.active_txns = int(value)
-            elif field == "Commit lock held for":
-                # This assumes
-                self.lock_time = time.time() - int(value)
-            elif field == "Commits":
-                self.commits = int(value)
-            elif field == "Aborts":
-                self.aborts = int(value)
-            elif field == "Loads":
-                self.loads = int(value)
-            elif field == "Stores":
-                self.stores = int(value)
-            elif field == "Conflicts":
-                self.conflicts = int(value)
-            elif field == "Conflicts resolved":
-                self.conflicts_resolved = int(value)
-
-    def dump(self, f):
-        print >> f, "Server started:", self.start
-        print >> f, "Clients:", self.clients
-        print >> f, "Clients verifying:", self.verifying_clients
-        print >> f, "Active transactions:", self.active_txns
-        if self.lock_time:
-            howlong = time.time() - self.lock_time
-            print >> f, "Commit lock held for:", int(howlong)
-        print >> f, "Commits:", self.commits
-        print >> f, "Aborts:", self.aborts
-        print >> f, "Loads:", self.loads
-        print >> f, "Stores:", self.stores
-        print >> f, "Conflicts:", self.conflicts
-        print >> f, "Conflicts resolved:", self.conflicts_resolved
-
-class StatsClient(asyncore.dispatcher):
-
-    def __init__(self, sock, addr):
-        asyncore.dispatcher.__init__(self, sock)
-        self.buf = []
-        self.closed = 0
-
-    def close(self):
-        self.closed = 1
-        # The socket is closed after all the data is written.
-        # See handle_write().
-
-    def write(self, s):
-        self.buf.append(s)
-
-    def writable(self):
-        return len(self.buf)
-
-    def readable(self):
-        return 0
-
-    def handle_write(self):
-        s = "".join(self.buf)
-        self.buf = []
-        n = self.socket.send(s)
-        if n < len(s):
-            self.buf.append(s[:n])
-
-        if self.closed and not self.buf:
-            asyncore.dispatcher.close(self)
-
-class StatsServer(asyncore.dispatcher):
-
-    StatsConnectionClass = StatsClient
-
-    def __init__(self, addr, stats):
-        asyncore.dispatcher.__init__(self)
-        self.addr = addr
-        self.stats = stats
-        if type(self.addr) == tuple:
-            self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
-        else:
-            self.create_socket(socket.AF_UNIX, socket.SOCK_STREAM)
-        self.set_reuse_addr()
-        logger = logging.getLogger('ZEO.monitor')
-        logger.info("listening on %s", repr(self.addr))
-        self.bind(self.addr)
-        self.listen(5)
-
-    def writable(self):
-        return 0
-
-    def readable(self):
-        return 1
-
-    def handle_accept(self):
-        try:
-            sock, addr = self.accept()
-        except socket.error:
-            return
-        f = self.StatsConnectionClass(sock, addr)
-        self.dump(f)
-        f.close()
-
-    def dump(self, f):
-        print >> f, "ZEO monitor server version %s" % zeo_version
-        print >> f, time.ctime()
-        print >> f
-
-        L = self.stats.keys()
-        L.sort()
-        for k in L:
-            stats = self.stats[k]
-            print >> f, "Storage:", k
-            stats.dump(f)
-            print >> f

src/ZEO/protocol.txt

-ZEO Network Protocol (sans authentication)
-==========================================
-
-This document describes the ZEO network protocol.  It assumes that the
-optional authentication protocol isn't used.  At the lowest
-level, the protocol consists of sized messages.  All communication
-between the client and server consists of sized messages.  A sized
-message consists of a 4-byte unsigned big-endian content length,
-followed by the content.  There are two subprotocols, for protocol
-negotiation, and for normal operation.  The normal operation protocol
-is a basic RPC protocol.
-
-In the protocol negotiation phase, the server sends a protocol
-identifier to the client.  The client chooses a protocol to use to the
-server. The client or the server can fail if it doesn't like the
-protocol string sent by the other party.  After sending their protocol
-strings, the client and server switch to RPC mode.
-
-The RPC protocol uses messages that are pickled tuples consisting of:
-
-message_id
-   The message id is used to match replies with requests, allowing
-   multiple outstanding synchronous requests.
-
-async_flag
-   An integer 0 for a regular (2-way) request and 1 for a one-way
-   request. Two-way requests have a reply.  One way requests don't.
-   ZRS tries to use as many one-way requests as possible to avoid
-   network round trips.
-
-name
-   The name of a method to call. If this is the special string
-   ".reply", then the message is interpreted as a return from a
-   synchronous call.
-
-args
-   A tuple of positional arguments or returned values.
-
-After making a connection and negotiating the protocol, the following
-interactions occur:
-
-- The client requests the authentication protocol by calling
-  getAuthProtocol.  For this discussion, we'll assume the server
-  returns None. Note that if the server doesn't require
-  authentication, this step is optional.
-
-- The client calls register passing a storage identifier and a
-  read-only flag.  The server doesn't return a value, but it may raise
-  an exception either if the storage doesn't exist, or if the
-  storage is readonly and the read-only flag passed by the client is
-  false.
-
-At this point, the client and server send each other messages as
-needed.  The client may make regular or one-way calls to the
-server. The server sends replies and one-way calls to the client.

src/ZEO/schema.xml

-<schema>
-
-  <!-- note that zeoctl.xml is a closely related schema which should
-       match this schema, but should require the "runner" section -->
-
-  <description>
-    This schema describes the configuration of the ZEO storage server
-    process.
-  </description>
-
-  <!-- Use the storage types defined by ZODB. -->
-  <import package="ZODB"/>
-
-  <!-- Use the ZEO server information structure. -->
-  <import package="ZEO"/>
-
-  <import package="ZConfig.components.logger"/>
-
-  <!-- runner control -->
-  <import package="zdaemon"/>
-
-
-  <section type="zeo" name="*" required="yes" attribute="zeo" />
-
-  <section type="runner" name="*" required="no" attribute="runner" />
-
-  <multisection name="*" type="ZODB.storage"
-                attribute="storages"
-                required="yes">
-    <description>
-      One or more storages that are provided by the ZEO server.  The
-      section names are used as the storage names, and must be unique
-      within each ZEO storage server.  Traditionally, these names
-      represent small integers starting at '1'.
-    </description>
-  </multisection>
-
-  <section name="*" type="eventlog" attribute="eventlog" required="no" />
-
-</schema>

src/ZEO/scripts/__init__.py

-#

src/ZEO/scripts/tests.py

-##############################################################################
-#
-# Copyright (c) 2004 Zope Foundation and Contributors.
-# All Rights Reserved.
-#
-# This software is subject to the provisions of the Zope Public License,
-# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
-# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
-# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
-# FOR A PARTICULAR PURPOSE.
-#
-##############################################################################
-import doctest, re, unittest
-from zope.testing import renormalizing
-
-def test_suite():
-    return unittest.TestSuite((
-        doctest.DocFileSuite(
-            'zeopack.test',
-            checker=renormalizing.RENormalizing([
-                (re.compile('usage: Usage: '), 'Usage: '), # Py 2.4
-                (re.compile('options:'), 'Options:'), # Py 2.4
-                ])
-            ),
-        ))
-

src/ZEO/tests/__init__.py

-##############################################################################
-#
-# Copyright (c) 2001, 2002 Zope Foundation and Contributors.
-# All Rights Reserved.
-#
-# This software is subject to the provisions of the Zope Public License,
-# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
-# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
-# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
-# FOR A PARTICULAR PURPOSE
-#
-##############################################################################

src/ZEO/version.txt

-3.7.0b3