def main(host, port, unix=None, days=1, username=None, password=None, realm=None, blob_dir=None, storage='1'): if unix is not None: addr = unix else: if host is None: host = socket.gethostname() addr = host, int(port) wait = True cs = None try: if HAS_BLOB: cs = ClientStorage( addr, storage=storage, wait=wait, read_only=True, username=username, password=password, realm=realm, blob_dir=blob_dir ) else: cs = ClientStorage( addr, storage=storage, wait=wait, read_only=True, username=username, password=password, realm=realm ) cs.pack(wait=wait, days=int(days)) finally: if cs is not None: cs.close()
def _main(host, port, unix=None, days=1, username=None, password=None, realm=None, blob_dir=None, storage='1', shared_blob_dir=True): if unix is not None: addr = unix else: if host is None: host = socket.gethostname() addr = host, int(port) if blob_dir: blob_dir = os.path.abspath(blob_dir) # We do not want to wait until a zeoserver is up and running; it # should already be running. wait = False cs = None try: cs = ClientStorage( addr, storage=storage, wait=wait, read_only=True, username=username, password=password, realm=realm, blob_dir=blob_dir, shared_blob_dir=shared_blob_dir, ) try: cs.pack(wait=wait, days=int(days)) except ClientDisconnected: logger = logging.getLogger(__name__) logger.error("Could not connect to zeoserver. Please make sure it " "is running.") sys.exit(1) finally: if cs is not None: cs.close()
def pack(addr, storage, days, wait): cs = ClientStorage(addr, storage=storage, wait_for_server_on_startup=wait) if wait: # _startup() is an artifact of the way ZEO 1.0 works. The # ClientStorage doesn't get fully initialized until registerDB() # is called. The only thing we care about, though, is that # registerDB() calls _startup(). cs._startup() else: connect(cs) cs.invalidator = None cs.pack(wait=1, days=days) cs.close()
class remoteZODB(object): def __init__(self, server, port): server_and_port = (server, port) self.storage = ClientStorage(server_and_port, storage='data', read_only=True, wait=False, ) self.db = DB(self.storage) self.connection = self.db.open() self.dbroot = self.connection.root() def close(self): self.connection.close() self.db.close() self.storage.close()
def checkVolatileCacheWithImmediateLastTransaction(self): # Earlier, a ClientStorage would not have the last transaction id # available right after successful connection, this is required now. addr = self._storage._addr storage2 = ClientStorage(addr) self.assert_(storage2.is_connected()) self.assertEquals(None, storage2.lastTransaction()) storage2.close() self._dostore() storage3 = ClientStorage(addr) self.assert_(storage3.is_connected()) self.assertEquals(8, len(storage3.lastTransaction())) self.assertNotEquals(ZODB.utils.z64, storage3.lastTransaction()) storage3.close()
class DB(BaseDB): def __init__(self, server=SERVER, port=PORT): self.storage = ClientStorage((server, port,)) self.db = ZDB(self.storage) self.connection = self.db.open() self.dbroot = self.connection.root() # KISS policy # let the lookup raise its own exception on a key lookup problem, etc def get(self, key): return self.dbroot[key] def put(self, key, data): self.dbroot[key] = data def update(self, key, data): if isinstance(data, Persistent): data._p_changed = True else: self.dbroot[key] = data def delete(self, key): if key in self.dbroot: del self.dbroot[key] def commit(self): transaction.commit() def abort(self): transaction.abort() def contains(self, key): return key in self.dbroot def close(self): self.connection.close() self.db.close() self.storage.close()
def checkZEOInvalidation(self): addr = self._storage._addr storage2 = ClientStorage(addr, wait=1, min_disconnect_poll=0.1) try: oid = self._storage.new_oid() ob = MinPO('first') revid1 = self._dostore(oid, data=ob) data, serial = storage2.load(oid, '') self.assertEqual(zodb_unpickle(data), MinPO('first')) self.assertEqual(serial, revid1) revid2 = self._dostore(oid, data=MinPO('second'), revid=revid1) for n in range(3): # Let the server and client talk for a moment. # Is there a better way to do this? asyncore.poll(0.1) data, serial = storage2.load(oid, '') self.assertEqual(zodb_unpickle(data), MinPO('second'), 'Invalidation message was not sent!') self.assertEqual(serial, revid2) finally: storage2.close()
def check_server(addr, storage, write): t0 = time.time() if ZEO_VERSION == 2: # TODO: should do retries w/ exponential backoff. cs = ClientStorage(addr, storage=storage, wait=0, read_only=(not write)) else: cs = ClientStorage(addr, storage=storage, debug=1, wait_for_server_on_startup=1) # _startup() is an artifact of the way ZEO 1.0 works. The # ClientStorage doesn't get fully initialized until registerDB() # is called. The only thing we care about, though, is that # registerDB() calls _startup(). if write: db = ZODB.DB(cs) cn = db.open() root = cn.root() try: # We store the data in a special `monitor' dict under the root, # where other tools may also store such heartbeat and bookkeeping # type data. monitor = root.get('monitor') if monitor is None: monitor = root['monitor'] = PersistentMapping() obj = monitor['zeoup'] = monitor.get('zeoup', MinPO(0)) obj.value += 1 transaction.commit() except ConflictError: pass cn.close() db.close() else: data, serial = cs.load("\0\0\0\0\0\0\0\0", "") cs.close() t1 = time.time() print "Elapsed time: %.2f" % (t1 - t0)
def checkZEOInvalidation(self): addr = self._storage._addr storage2 = ClientStorage(addr, wait=1, min_disconnect_poll=0.1) try: oid = self._storage.new_oid() ob = MinPO("first") revid1 = self._dostore(oid, data=ob) data, serial = storage2.load(oid, "") self.assertEqual(zodb_unpickle(data), MinPO("first")) self.assertEqual(serial, revid1) revid2 = self._dostore(oid, data=MinPO("second"), revid=revid1) # Now, storage 2 should eventually get the new data. It # will take some time, although hopefully not much. # We'll poll till we get it and whine if we time out: for n in range(30): time.sleep(0.1) data, serial = storage2.load(oid, "") if serial == revid2 and zodb_unpickle(data) == MinPO("second"): break else: raise AssertionError("Invalidation message was not sent!") finally: storage2.close()
def _main(host, port, unix=None, days=1, username=None, password=None, realm=None, blob_dir=None, storage='1', shared_blob_dir=True): if unix is not None: addr = unix else: if host is None: host = socket.gethostname() addr = host, int(port) if blob_dir: blob_dir = os.path.abspath(blob_dir) wait = True cs = None try: cs = ClientStorage( addr, storage=storage, wait=wait, read_only=True, username=username, password=password, realm=realm, blob_dir=blob_dir, shared_blob_dir=shared_blob_dir, ) cs.pack(wait=wait, days=int(days)) finally: if cs is not None: cs.close()
class GenericTests( # Base class for all ZODB tests StorageTestBase.StorageTestBase, # ZODB test mixin classes (in the same order as imported) BasicStorage.BasicStorage, PackableStorage.PackableStorage, Synchronization.SynchronizedStorage, MTStorage.MTStorage, ReadOnlyStorage.ReadOnlyStorage, # ZEO test mixin classes (in the same order as imported) CommitLockTests.CommitLockVoteTests, ThreadTests.ThreadTests, # Locally defined (see above) MiscZEOTests, ): """Combine tests from various origins in one class.""" shared_blob_dir = False blob_cache_dir = None def setUp(self): StorageTestBase.StorageTestBase.setUp(self) logger.info("setUp() %s", self.id()) port = get_port(self) zconf = forker.ZEOConfig(("", port)) zport, adminaddr, pid, path = forker.start_zeo_server(self.getConfig(), zconf, port) self._pids = [pid] self._servers = [adminaddr] self._conf_path = path if not self.blob_cache_dir: # This is the blob cache for ClientStorage self.blob_cache_dir = tempfile.mkdtemp("blob_cache", dir=os.path.abspath(os.getcwd())) self._storage = ClientStorage( zport, "1", cache_size=20000000, min_disconnect_poll=0.5, wait=1, wait_timeout=60, blob_dir=self.blob_cache_dir, shared_blob_dir=self.shared_blob_dir, ) self._storage.registerDB(DummyDB()) def tearDown(self): self._storage.close() for server in self._servers: forker.shutdown_zeo_server(server) if hasattr(os, "waitpid"): # Not in Windows Python until 2.3 for pid in self._pids: os.waitpid(pid, 0) StorageTestBase.StorageTestBase.tearDown(self) def runTest(self): try: super(GenericTests, self).runTest() except: self._failed = True raise else: self._failed = False def open(self, read_only=0): # Needed to support ReadOnlyStorage tests. Ought to be a # cleaner way. addr = self._storage._addr self._storage.close() self._storage = ClientStorage(addr, read_only=read_only, wait=1) def checkWriteMethods(self): # ReadOnlyStorage defines checkWriteMethods. The decision # about where to raise the read-only error was changed after # Zope 2.5 was released. So this test needs to detect Zope # of the 2.5 vintage and skip the test. # The __version__ attribute was not present in Zope 2.5. if hasattr(ZODB, "__version__"): ReadOnlyStorage.ReadOnlyStorage.checkWriteMethods(self) def checkSortKey(self): key = "%s:%s" % (self._storage._storage, self._storage._server_addr) self.assertEqual(self._storage.sortKey(), key)
def close(self): ClientStorage.close(self) zope.testing.setupstack.tearDown(self)
def pack2(addr, storage, days): cs = ClientStorage(addr, storage=storage, wait=1, read_only=1) cs.pack(wait=1, days=days) cs.close()
def pack2(addr, storage, days): cs = ClientStorage(addr, storage=storage, wait=1, read_only=1) cs.pack(wait=1, days=days) cs.close()
class GenericTests( # Base class for all ZODB tests StorageTestBase.StorageTestBase, # ZODB test mixin classes (in the same order as imported) BasicStorage.BasicStorage, PackableStorage.PackableStorage, Synchronization.SynchronizedStorage, MTStorage.MTStorage, ReadOnlyStorage.ReadOnlyStorage, # ZEO test mixin classes (in the same order as imported) CommitLockTests.CommitLockVoteTests, ThreadTests.ThreadTests, # Locally defined (see above) MiscZEOTests ): """Combine tests from various origins in one class.""" def setUp(self): logger.info("setUp() %s", self.id()) port = get_port() zconf = forker.ZEOConfig(('', port)) zport, adminaddr, pid, path = forker.start_zeo_server(self.getConfig(), zconf, port) self._pids = [pid] self._servers = [adminaddr] self._conf_path = path self._storage = ClientStorage(zport, '1', cache_size=20000000, min_disconnect_poll=0.5, wait=1, wait_timeout=60) self._storage.registerDB(DummyDB(), None) def tearDown(self): self._storage.close() os.remove(self._conf_path) for server in self._servers: forker.shutdown_zeo_server(server) if hasattr(os, 'waitpid'): # Not in Windows Python until 2.3 for pid in self._pids: os.waitpid(pid, 0) def open(self, read_only=0): # Needed to support ReadOnlyStorage tests. Ought to be a # cleaner way. addr = self._storage._addr self._storage.close() self._storage = ClientStorage(addr, read_only=read_only, wait=1) def checkWriteMethods(self): # ReadOnlyStorage defines checkWriteMethods. The decision # about where to raise the read-only error was changed after # Zope 2.5 was released. So this test needs to detect Zope # of the 2.5 vintage and skip the test. # The __version__ attribute was not present in Zope 2.5. if hasattr(ZODB, "__version__"): ReadOnlyStorage.ReadOnlyStorage.checkWriteMethods(self) def checkSortKey(self): key = '%s:%s' % (self._storage._storage, self._storage._server_addr) self.assertEqual(self._storage.sortKey(), key)
class GenericTests( # Base class for all ZODB tests StorageTestBase.StorageTestBase, # ZODB test mixin classes (in the same order as imported) BasicStorage.BasicStorage, PackableStorage.PackableStorage, Synchronization.SynchronizedStorage, MTStorage.MTStorage, ReadOnlyStorage.ReadOnlyStorage, # ZEO test mixin classes (in the same order as imported) CommitLockTests.CommitLockVoteTests, ThreadTests.ThreadTests, # Locally defined (see above) MiscZEOTests): """Combine tests from various origins in one class.""" shared_blob_dir = False blob_cache_dir = None def setUp(self): logger.info("setUp() %s", self.id()) port = get_port() zconf = forker.ZEOConfig(('', port)) zport, adminaddr, pid, path = forker.start_zeo_server( self.getConfig(), zconf, port) self._pids = [pid] self._servers = [adminaddr] self._conf_path = path if not self.blob_cache_dir: # This is the blob cache for ClientStorage self.blob_cache_dir = tempfile.mkdtemp() self._storage = ClientStorage(zport, '1', cache_size=20000000, min_disconnect_poll=0.5, wait=1, wait_timeout=60, blob_dir=self.blob_cache_dir, shared_blob_dir=self.shared_blob_dir) self._storage.registerDB(DummyDB()) def tearDown(self): self._storage.close() os.remove(self._conf_path) ZODB.blob.remove_committed_dir(self.blob_cache_dir) for server in self._servers: forker.shutdown_zeo_server(server) if hasattr(os, 'waitpid'): # Not in Windows Python until 2.3 for pid in self._pids: os.waitpid(pid, 0) def open(self, read_only=0): # Needed to support ReadOnlyStorage tests. Ought to be a # cleaner way. addr = self._storage._addr self._storage.close() self._storage = ClientStorage(addr, read_only=read_only, wait=1) def checkWriteMethods(self): # ReadOnlyStorage defines checkWriteMethods. The decision # about where to raise the read-only error was changed after # Zope 2.5 was released. So this test needs to detect Zope # of the 2.5 vintage and skip the test. # The __version__ attribute was not present in Zope 2.5. if hasattr(ZODB, "__version__"): ReadOnlyStorage.ReadOnlyStorage.checkWriteMethods(self) def checkSortKey(self): key = '%s:%s' % (self._storage._storage, self._storage._server_addr) self.assertEqual(self._storage.sortKey(), key)