예제 #1
0
    def __init__(self,
                 storage,
                 pool_size=7,
                 pool_timeout=1<<31,
                 cache_size=400,
                 cache_size_bytes=0,
                 historical_pool_size=3,
                 historical_cache_size=1000,
                 historical_cache_size_bytes=0,
                 historical_timeout=300,
                 database_name='unnamed',
                 databases=None,
                 xrefs=True,
                 large_record_size=1<<24,
                 **storage_args):
        """Create an object database.

        :param storage: the storage used by the database, such as a
             :class:`~ZODB.FileStorage.FileStorage.FileStorage`.
             This can be a string path name to use a constructed
             :class:`~ZODB.FileStorage.FileStorage.FileStorage`
             storage or ``None`` to use a constructed
             :class:`~ZODB.MappingStorage.MappingStorage`.
        :param int pool_size: expected maximum number of open connections.
             Warnings are logged when this is exceeded and critical
             messages are logged if twice the pool size is exceeded.
        :param seconds pool_timeout: Maximum age of inactive connections
             When a connection has remained unused in a connection
             pool for more than pool_timeout seconds, it will be
             discarded and it's resources released.
        :param objects cache_size: target maximum number of non-ghost
             objects in each connection object cache.
        :param int cache_size_bytes: target total memory usage of non-ghost
             objects in each connection object cache.
        :param int historical_pool_size: expected maximum number of total
            historical connections
        :param objects historical_cache_size: target maximum number
             of non-ghost objects in each historical connection object
             cache.
        :param int historical_cache_size_bytes: target total memory
             usage of non-ghost objects in each historical connection
             object cache.
        :param seconds historical_timeout: Maximum age of inactive
             historical connections.  When a connection has remained
             unused in a historical connection pool for more than pool_timeout
             seconds, it will be discarded and it's resources
             released.
        :param str database_name: The name of this database in a
             multi-database configuration.  The name is used when
             constructing cross-database references ans when accessing
             database connections fron other databases.
        :param dict databases: dictionary of database name to
             databases in a multi-database configuration. The new
             database will add itself to this dictionary. The
             dictionary is used when getting connections in other databases.
        :param boolean xrefs: Flag indicating whether cross-database
            references are allowed from this database to other
            databases in a multi-database configuration.
        :param int large_record_size: When object records are saved
             that are larger than this, a warning is issued,
             suggesting that blobs should be used instead.
        :param storage_args: Extra keywork arguments passed to a
             storage constructor if a path name or None is passed as
             the storage argument.
        """

        # Allocate lock.
        self._lock = utils.RLock()

        # pools and cache sizes
        self.pool = ConnectionPool(pool_size, pool_timeout)
        self.historical_pool = KeyedConnectionPool(historical_pool_size,
                                                   historical_timeout)
        self._cache_size = cache_size
        self._cache_size_bytes = cache_size_bytes
        self._historical_cache_size = historical_cache_size
        self._historical_cache_size_bytes = historical_cache_size_bytes

        # Setup storage
        if isinstance(storage, six.string_types):
            from ZODB import FileStorage
            storage = ZODB.FileStorage.FileStorage(storage, **storage_args)
        elif storage is None:
            from ZODB import MappingStorage
            storage = ZODB.MappingStorage.MappingStorage(**storage_args)
        else:
            assert not storage_args

        self.storage = storage

        if IMVCCStorage.providedBy(storage):
            self._mvcc_storage = storage
        else:
            from .mvccadapter import MVCCAdapter
            self._mvcc_storage = MVCCAdapter(storage)

        self.references = ZODB.serialize.referencesf

        if (not hasattr(storage, 'tpc_vote')) and not storage.isReadOnly():
            warnings.warn(
                "Storage doesn't have a tpc_vote and this violates "
                "the storage API. Violently monkeypatching in a do-nothing "
                "tpc_vote.",
                DeprecationWarning, 2)
            storage.tpc_vote = lambda *args: None

        # Multi-database setup.
        if databases is None:
            databases = {}
        self.databases = databases
        self.database_name = database_name
        if database_name in databases:
            raise ValueError("database_name %r already in databases" %
                             database_name)
        databases[database_name] = self
        self.xrefs = xrefs

        self.large_record_size = large_record_size

        # Make sure we have a root:
        with self.transaction(u'initial database creation') as conn:
            try:
                conn.get(z64)
            except KeyError:
                from persistent.mapping import PersistentMapping
                root = PersistentMapping()
                conn._add(root, z64)
예제 #2
0
파일: DB.py 프로젝트: denishom12/decorator
    def __init__(self,
                 storage,
                 pool_size=7,
                 pool_timeout=1<<31,
                 cache_size=400,
                 cache_size_bytes=0,
                 historical_pool_size=3,
                 historical_cache_size=1000,
                 historical_cache_size_bytes=0,
                 historical_timeout=300,
                 database_name='unnamed',
                 databases=None,
                 xrefs=True,
                 large_record_size=1<<24,
                 **storage_args):
        """Create an object database.

        :param storage: the storage used by the database, such as a
             :class:`~ZODB.FileStorage.FileStorage.FileStorage`.
             This can be a string path name to use a constructed
             :class:`~ZODB.FileStorage.FileStorage.FileStorage`
             storage or ``None`` to use a constructed
             :class:`~ZODB.MappingStorage.MappingStorage`.
        :param int pool_size: expected maximum number of open connections.
             Warnings are logged when this is exceeded and critical
             messages are logged if twice the pool size is exceeded.
        :param seconds pool_timeout: Maximum age of inactive connections
             When a connection has remained unused in a connection
             pool for more than pool_timeout seconds, it will be
             discarded and it's resources released.
        :param objects cache_size: target maximum number of non-ghost
             objects in each connection object cache.
        :param int cache_size_bytes: target total memory usage of non-ghost
             objects in each connection object cache.
        :param int historical_pool_size: expected maximum number of total
            historical connections
        :param objects historical_cache_size: target maximum number
             of non-ghost objects in each historical connection object
             cache.
        :param int historical_cache_size_bytes: target total memory
             usage of non-ghost objects in each historical connection
             object cache.
        :param seconds historical_timeout: Maximum age of inactive
             historical connections.  When a connection has remained
             unused in a historical connection pool for more than pool_timeout
             seconds, it will be discarded and it's resources
             released.
        :param str database_name: The name of this database in a
             multi-database configuration.  The name is used when
             constructing cross-database references ans when accessing
             database connections fron other databases.
        :param dict databases: dictionary of database name to
             databases in a multi-database configuration. The new
             database will add itself to this dictionary. The
             dictionary is used when getting connections in other databases.
        :param boolean xrefs: Flag indicating whether cross-database
            references are allowed from this database to other
            databases in a multi-database configuration.
        :param int large_record_size: When object records are saved
             that are larger than this, a warning is issued,
             suggesting that blobs should be used instead.
        :param storage_args: Extra keywork arguments passed to a
             storage constructor if a path name or None is passed as
             the storage argument.
        """

        # Allocate lock.
        self._lock = utils.RLock()

        # pools and cache sizes
        self.pool = ConnectionPool(pool_size, pool_timeout)
        self.historical_pool = KeyedConnectionPool(historical_pool_size,
                                                   historical_timeout)
        self._cache_size = cache_size
        self._cache_size_bytes = cache_size_bytes
        self._historical_cache_size = historical_cache_size
        self._historical_cache_size_bytes = historical_cache_size_bytes

        # Setup storage
        if isinstance(storage, six.string_types):
            from ZODB import FileStorage
            storage = ZODB.FileStorage.FileStorage(storage, **storage_args)
        elif storage is None:
            from ZODB import MappingStorage
            storage = ZODB.MappingStorage.MappingStorage(**storage_args)
        else:
            assert not storage_args

        self.storage = storage

        if IMVCCStorage.providedBy(storage):
            self._mvcc_storage = storage
        else:
            from .mvccadapter import MVCCAdapter
            self._mvcc_storage = MVCCAdapter(storage)

        self.references = ZODB.serialize.referencesf

        if (not hasattr(storage, 'tpc_vote')) and not storage.isReadOnly():
            warnings.warn(
                "Storage doesn't have a tpc_vote and this violates "
                "the storage API. Violently monkeypatching in a do-nothing "
                "tpc_vote.",
                DeprecationWarning, 2)
            storage.tpc_vote = lambda *args: None

        # Multi-database setup.
        if databases is None:
            databases = {}
        self.databases = databases
        self.database_name = database_name
        if database_name in databases:
            raise ValueError("database_name %r already in databases" %
                             database_name)
        databases[database_name] = self
        self.xrefs = xrefs

        self.large_record_size = large_record_size

        # Make sure we have a root:
        with self.transaction(u'initial database creation') as conn:
            try:
                conn.get(z64)
            except KeyError:
                from persistent.mapping import PersistentMapping
                root = PersistentMapping()
                conn._add(root, z64)
예제 #3
0
    def __init__(self,
                 storage,
                 pool_size=7,
                 pool_timeout=1 << 31,
                 cache_size=400,
                 cache_size_bytes=0,
                 historical_pool_size=3,
                 historical_cache_size=1000,
                 historical_cache_size_bytes=0,
                 historical_timeout=300,
                 database_name='unnamed',
                 databases=None,
                 xrefs=True,
                 large_record_size=1 << 24,
                 **storage_args):
        """Create an object database.

        :Parameters:
          - `storage`: the storage used by the database, e.g. FileStorage
          - `pool_size`: expected maximum number of open connections
          - `cache_size`: target size of Connection object cache
          - `cache_size_bytes`: target size measured in total estimated size
               of objects in the Connection object cache.
               "0" means unlimited.
          - `historical_pool_size`: expected maximum number of total
            historical connections
          - `historical_cache_size`: target size of Connection object cache for
            historical (`at` or `before`) connections
          - `historical_cache_size_bytes` -- similar to `cache_size_bytes` for
            the historical connection.
          - `historical_timeout`: minimum number of seconds that
            an unused historical connection will be kept, or None.
          - `xrefs` - Boolian flag indicating whether implicit cross-database
            references are allowed
        """

        # Allocate lock.
        self._lock = utils.RLock()

        # pools and cache sizes
        self.pool = ConnectionPool(pool_size, pool_timeout)
        self.historical_pool = KeyedConnectionPool(historical_pool_size,
                                                   historical_timeout)
        self._cache_size = cache_size
        self._cache_size_bytes = cache_size_bytes
        self._historical_cache_size = historical_cache_size
        self._historical_cache_size_bytes = historical_cache_size_bytes

        # Setup storage
        if isinstance(storage, six.string_types):
            from ZODB import FileStorage
            storage = ZODB.FileStorage.FileStorage(storage, **storage_args)
        elif storage is None:
            from ZODB import MappingStorage
            storage = ZODB.MappingStorage.MappingStorage(**storage_args)
        else:
            assert not storage_args

        self.storage = storage

        if IMVCCStorage.providedBy(storage):
            self._mvcc_storage = storage
        else:
            from .mvccadapter import MVCCAdapter
            self._mvcc_storage = MVCCAdapter(storage)

        self.references = ZODB.serialize.referencesf

        if (not hasattr(storage, 'tpc_vote')) and not storage.isReadOnly():
            warnings.warn(
                "Storage doesn't have a tpc_vote and this violates "
                "the storage API. Violently monkeypatching in a do-nothing "
                "tpc_vote.", DeprecationWarning, 2)
            storage.tpc_vote = lambda *args: None

        # Multi-database setup.
        if databases is None:
            databases = {}
        self.databases = databases
        self.database_name = database_name
        if database_name in databases:
            raise ValueError("database_name %r already in databases" %
                             database_name)
        databases[database_name] = self
        self.xrefs = xrefs

        self.large_record_size = large_record_size

        # Make sure we have a root:
        with self.transaction('initial database creation') as conn:
            try:
                conn.get(z64)
            except KeyError:
                from persistent.mapping import PersistentMapping
                root = PersistentMapping()
                conn._add(root, z64)
예제 #4
0
    def __init__(self, storage,
                 pool_size=7,
                 pool_timeout=1<<31,
                 cache_size=400,
                 cache_size_bytes=0,
                 historical_pool_size=3,
                 historical_cache_size=1000,
                 historical_cache_size_bytes=0,
                 historical_timeout=300,
                 database_name='unnamed',
                 databases=None,
                 xrefs=True,
                 large_record_size=1<<24,
                 **storage_args):
        """Create an object database.

        :Parameters:
          - `storage`: the storage used by the database, e.g. FileStorage
          - `pool_size`: expected maximum number of open connections
          - `cache_size`: target size of Connection object cache
          - `cache_size_bytes`: target size measured in total estimated size
               of objects in the Connection object cache.
               "0" means unlimited.
          - `historical_pool_size`: expected maximum number of total
            historical connections
          - `historical_cache_size`: target size of Connection object cache for
            historical (`at` or `before`) connections
          - `historical_cache_size_bytes` -- similar to `cache_size_bytes` for
            the historical connection.
          - `historical_timeout`: minimum number of seconds that
            an unused historical connection will be kept, or None.
          - `xrefs` - Boolian flag indicating whether implicit cross-database
            references are allowed
        """
        if isinstance(storage, basestring):
            from ZODB import FileStorage
            storage = ZODB.FileStorage.FileStorage(storage, **storage_args)
        elif storage is None:
            from ZODB import MappingStorage
            storage = ZODB.MappingStorage.MappingStorage(**storage_args)

        # Allocate lock.
        x = threading.RLock()
        self._a = x.acquire
        self._r = x.release

        # pools and cache sizes
        self.pool = ConnectionPool(pool_size, pool_timeout)
        self.historical_pool = KeyedConnectionPool(historical_pool_size,
                                                   historical_timeout)
        self._cache_size = cache_size
        self._cache_size_bytes = cache_size_bytes
        self._historical_cache_size = historical_cache_size
        self._historical_cache_size_bytes = historical_cache_size_bytes

        # Setup storage
        self.storage = storage
        self.references = ZODB.serialize.referencesf
        try:
            storage.registerDB(self)
        except TypeError:
            storage.registerDB(self, None) # Backward compat

        if (not hasattr(storage, 'tpc_vote')) and not storage.isReadOnly():
            warnings.warn(
                "Storage doesn't have a tpc_vote and this violates "
                "the storage API. Violently monkeypatching in a do-nothing "
                "tpc_vote.",
                DeprecationWarning, 2)
            storage.tpc_vote = lambda *args: None

        if IMVCCStorage.providedBy(storage):
            temp_storage = storage.new_instance()
        else:
            temp_storage = storage
        try:
            try:
                temp_storage.load(z64, '')
            except KeyError:
                # Create the database's root in the storage if it doesn't exist
                from persistent.mapping import PersistentMapping
                root = PersistentMapping()
                # Manually create a pickle for the root to put in the storage.
                # The pickle must be in the special ZODB format.
                file = cStringIO.StringIO()
                p = cPickle.Pickler(file, 1)
                p.dump((root.__class__, None))
                p.dump(root.__getstate__())
                t = transaction.Transaction()
                t.description = 'initial database creation'
                temp_storage.tpc_begin(t)
                temp_storage.store(z64, None, file.getvalue(), '', t)
                temp_storage.tpc_vote(t)
                temp_storage.tpc_finish(t)
        finally:
            if IMVCCStorage.providedBy(temp_storage):
                temp_storage.release()

        # Multi-database setup.
        if databases is None:
            databases = {}
        self.databases = databases
        self.database_name = database_name
        if database_name in databases:
            raise ValueError("database_name %r already in databases" %
                             database_name)
        databases[database_name] = self
        self.xrefs = xrefs

        self.large_record_size = large_record_size
예제 #5
0
파일: DB.py 프로젝트: grodniewicz/oship
    def __init__(
        self,
        storage,
        pool_size=7,
        pool_timeout=1 << 31,
        cache_size=400,
        cache_size_bytes=0,
        historical_pool_size=3,
        historical_cache_size=1000,
        historical_cache_size_bytes=0,
        historical_timeout=300,
        database_name="unnamed",
        databases=None,
        xrefs=True,
    ):
        """Create an object database.

        :Parameters:
          - `storage`: the storage used by the database, e.g. FileStorage
          - `pool_size`: expected maximum number of open connections
          - `cache_size`: target size of Connection object cache
          - `cache_size_bytes`: target size measured in total estimated size
               of objects in the Connection object cache.
               "0" means unlimited.
          - `historical_pool_size`: expected maximum number of total
            historical connections
          - `historical_cache_size`: target size of Connection object cache for
            historical (`at` or `before`) connections
          - `historical_cache_size_bytes` -- similar to `cache_size_bytes` for
            the historical connection.
          - `historical_timeout`: minimum number of seconds that
            an unused historical connection will be kept, or None.
          - `xrefs` - Boolian flag indicating whether implicit cross-database
            references are allowed
        """
        if isinstance(storage, basestring):
            from ZODB import FileStorage

            storage = ZODB.FileStorage.FileStorage(storage)

        # Allocate lock.
        x = threading.RLock()
        self._a = x.acquire
        self._r = x.release

        # pools and cache sizes
        self.pool = ConnectionPool(pool_size, pool_timeout)
        self.historical_pool = KeyedConnectionPool(historical_pool_size, historical_timeout)
        self._cache_size = cache_size
        self._cache_size_bytes = cache_size_bytes
        self._historical_cache_size = historical_cache_size
        self._historical_cache_size_bytes = historical_cache_size_bytes

        # Setup storage
        self.storage = storage
        self.references = ZODB.serialize.referencesf
        try:
            storage.registerDB(self)
        except TypeError:
            storage.registerDB(self, None)  # Backward compat

        if (not hasattr(storage, "tpc_vote")) and not storage.isReadOnly():
            warnings.warn(
                "Storage doesn't have a tpc_vote and this violates "
                "the storage API. Violently monkeypatching in a do-nothing "
                "tpc_vote.",
                DeprecationWarning,
                2,
            )
            storage.tpc_vote = lambda *args: None

        if IMVCCStorage.providedBy(storage):
            temp_storage = storage.new_instance()
        else:
            temp_storage = storage
        try:
            try:
                temp_storage.load(z64, "")
            except KeyError:
                # Create the database's root in the storage if it doesn't exist
                from persistent.mapping import PersistentMapping

                root = PersistentMapping()
                # Manually create a pickle for the root to put in the storage.
                # The pickle must be in the special ZODB format.
                file = cStringIO.StringIO()
                p = cPickle.Pickler(file, 1)
                p.dump((root.__class__, None))
                p.dump(root.__getstate__())
                t = transaction.Transaction()
                t.description = "initial database creation"
                temp_storage.tpc_begin(t)
                temp_storage.store(z64, None, file.getvalue(), "", t)
                temp_storage.tpc_vote(t)
                temp_storage.tpc_finish(t)
        finally:
            if IMVCCStorage.providedBy(temp_storage):
                temp_storage.release()

        # Multi-database setup.
        if databases is None:
            databases = {}
        self.databases = databases
        self.database_name = database_name
        if database_name in databases:
            raise ValueError("database_name %r already in databases" % database_name)
        databases[database_name] = self
        self.xrefs = xrefs

        self._setupUndoMethods()
        self.history = storage.history