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)
