Pyramid Project: comparison ProjectPyramid/APIs/ZEO-5.2.2.api

-:dcbd3a96f03c
+:da343a43e995
+.DB?4(*args, **kw)
+.client?4(*args, **kw)
+.connection?4(*args, **kw)
+.server?4(path=None, blob_dir=None, storage_conf=None, zeo_conf=None, port=0, threaded=True, **kw)
+ClientStorage.BlobCacheLayout.getBlobFilePath?4(oid, tid)
+ClientStorage.BlobCacheLayout.oid_to_path?4(oid)
+ClientStorage.BlobCacheLayout.size?7
+ClientStorage.ClientStorage._check_blob_size?5(bytes=None)
+ClientStorage.ClientStorage._check_blob_size_thread?8
+ClientStorage.ClientStorage._check_trans?5(trans, meth)
+ClientStorage.ClientStorage._connection_generation?8
+ClientStorage.ClientStorage._forget_iterator?5(iid)
+ClientStorage.ClientStorage._iterator_gc?5(disconnected=False)
+ClientStorage.ClientStorage._normalize_addr?5(addr)
+ClientStorage.ClientStorage._setup_iterator?5(factory, iid, *args)
+ClientStorage.ClientStorage._update_blob_cache?5(tbuf, tid)
+ClientStorage.ClientStorage.checkCurrentSerialInTransaction?4(oid, serial, transaction)
+ClientStorage.ClientStorage.close?4()
+ClientStorage.ClientStorage.copyTransactionsFrom?4(other, verbose=0)
+ClientStorage.ClientStorage.deleteObject?4(oid, serial, txn)
+ClientStorage.ClientStorage.getName?4()
+ClientStorage.ClientStorage.getSize?4()
+ClientStorage.ClientStorage.getTid?4(oid)
+ClientStorage.ClientStorage.history?4(oid, size=1)
+ClientStorage.ClientStorage.info?4(dict)
+ClientStorage.ClientStorage.invalidateCache?4()
+ClientStorage.ClientStorage.invalidateTransaction?4(tid, oids)
+ClientStorage.ClientStorage.isReadOnly?7
+ClientStorage.ClientStorage.is_connected?4(test=False)
+ClientStorage.ClientStorage.is_read_only?4()
+ClientStorage.ClientStorage.iterator?4(start=None, stop=None)
+ClientStorage.ClientStorage.lastTransaction?4()
+ClientStorage.ClientStorage.load?4(oid, version='')
+ClientStorage.ClientStorage.loadBefore?4(oid, tid)
+ClientStorage.ClientStorage.loadBlob?4(oid, serial)
+ClientStorage.ClientStorage.loadSerial?4(oid, serial)
+ClientStorage.ClientStorage.new_addr?4(addr)
+ClientStorage.ClientStorage.new_oid?4()
+ClientStorage.ClientStorage.notify_connected?4(conn, info)
+ClientStorage.ClientStorage.notify_disconnected?4()
+ClientStorage.ClientStorage.openCommittedBlobFile?4(oid, serial, blob=None)
+ClientStorage.ClientStorage.pack?4(t=None, referencesf=None, wait=1, days=0)
+ClientStorage.ClientStorage.prefetch?4(oids, tid)
+ClientStorage.ClientStorage.receiveBlobChunk?4(oid, serial, chunk)
+ClientStorage.ClientStorage.receiveBlobStart?4(oid, serial)
+ClientStorage.ClientStorage.receiveBlobStop?4(oid, serial)
+ClientStorage.ClientStorage.record_iternext?4(next=None)
+ClientStorage.ClientStorage.registerDB?4(db)
+ClientStorage.ClientStorage.restore?4(oid, serial, data, version, prev_txn, transaction)
+ClientStorage.ClientStorage.serialnos?4(args)
+ClientStorage.ClientStorage.server_status?4()
+ClientStorage.ClientStorage.set_server_addr?4(addr)
+ClientStorage.ClientStorage.sortKey?4()
+ClientStorage.ClientStorage.store?4()
+ClientStorage.ClientStorage.storeBlob?4(oid, serial, data, blobfilename, version, txn)
+ClientStorage.ClientStorage.supportsUndo?4()
+ClientStorage.ClientStorage.sync?4()
+ClientStorage.ClientStorage.temporaryDirectory?4()
+ClientStorage.ClientStorage.tpc_abort?4(txn, timeout=None)
+ClientStorage.ClientStorage.tpc_begin?4(txn, tid=None, status=' ')
+ClientStorage.ClientStorage.tpc_end?4(txn)
+ClientStorage.ClientStorage.tpc_finish?4(txn, f=lambda tid: None)
+ClientStorage.ClientStorage.tpc_transaction?4()
+ClientStorage.ClientStorage.tpc_vote?4(txn)
+ClientStorage.ClientStorage.undo?4(trans_id, txn)
+ClientStorage.ClientStorage.undoInfo?4(first=0, last=-20, specification=None)
+ClientStorage.ClientStorage.undoLog?4(first=0, last=-20, filter=None)
+ClientStorage.ClientStorage?1(addr, storage='1', cache_size=20 * MB, name='', wait_timeout=None, disconnect_poll=None, read_only=0, read_only_fallback=0, blob_dir=None, shared_blob_dir=False, blob_cache_size=None, blob_cache_size_check=10, client_label=None, cache=None, ssl = None, ssl_server_hostname=None, client=None, var=None, min_disconnect_poll=1, max_disconnect_poll=None, wait=True, drop_cache_rather_verify=True, credentials=None, server_sync=False, username=None, password=None, realm=None, _client_factory=ZEO.asyncio.client.ClientThread, )
+ClientStorage.ClientStorageTransactionInformation?1(storage, txiter, tid, status, user, description, extension)
+ClientStorage.MB?7
+ClientStorage.RecordIterator.next?7
+ClientStorage.RecordIterator?1(storage, riid)
+ClientStorage.TransactionIterator.next?7
+ClientStorage.TransactionIterator?1(storage, iid, *args)
+ClientStorage._accessed?5(filename)
+ClientStorage._check_blob_cache_size?5(blob_dir, target)
+ClientStorage._lock_blob?5(path)
+ClientStorage.cache_file_name?7
+ClientStorage.check_blob_size_script?4(args=None)
+ClientStorage.get_timestamp?4(prev_ts=None)
+ClientStorage.logger?7
+ClientStorage.open_cache?4(cache, var, client, storage, cache_size)
+ClientStorage.tid2time?4(tid)
+StorageServer.CommitLog.checkread?4(oid, serial)
+StorageServer.CommitLog.close?4()
+StorageServer.CommitLog.delete?4(oid, serial)
+StorageServer.CommitLog.restore?4(oid, serial, data, prev_txn)
+StorageServer.CommitLog.size?4()
+StorageServer.CommitLog.store?4(oid, serial, data)
+StorageServer.CommitLog.undo?4(transaction_id)
+StorageServer.CommitLog?1()
+StorageServer.LockManager._can_lock?5(zs)
+StorageServer.LockManager._lock_waiting?5(zs)
+StorageServer.LockManager._locked?5(zs)
+StorageServer.LockManager._log_waiting?5(zs, message)
+StorageServer.LockManager._unlocked?5(zs)
+StorageServer.LockManager.lock?4(zs, func)
+StorageServer.LockManager.release?4(zs)
+StorageServer.LockManager?1(storage_id, stats, timeout)
+StorageServer.ServerEvent?1(server, **kw)
+StorageServer.SlowMethodThread.run?4()
+StorageServer.SlowMethodThread?1(method, args)
+StorageServer.StorageServer._invalidateCache?5(storage_id)
+StorageServer.StorageServer._setup_invq?5(name, storage)
+StorageServer.StorageServer.broadcast_info?4(storage_id, info)
+StorageServer.StorageServer.close?4(join_timeout=1)
+StorageServer.StorageServer.close_conn?4(zeo_storage)
+StorageServer.StorageServer.create_client_handler?4()
+StorageServer.StorageServer.get_invalidations?4(storage_id, tid)
+StorageServer.StorageServer.invalidate?4(zeo_storage, storage_id, tid, invalidated)
+StorageServer.StorageServer.register_connection?4(storage_id, zeo_storage)
+StorageServer.StorageServer.ruok?4()
+StorageServer.StorageServer.server_status?4(storage_id)
+StorageServer.StorageServer.start_thread?4(daemon=True)
+StorageServer.StorageServer?1(addr, storages, read_only=0, invalidation_queue_size=100, invalidation_age=None, transaction_timeout=None, ssl=None, client_conflict_resolution=False, Acceptor=Acceptor, msgpack=False, )
+StorageServer.StorageServerDB.invalidate?4(tid, oids, version='')
+StorageServer.StorageServerDB.invalidateCache?4()
+StorageServer.StorageServerDB.transform_record_data?7
+StorageServer.StorageServerDB?1(server, storage_id)
+StorageServer.StubTimeoutThread.begin?4(client)
+StorageServer.StubTimeoutThread.end?4(client)
+StorageServer.StubTimeoutThread.is_alive?7
+StorageServer.TimeoutThread.begin?4(client)
+StorageServer.TimeoutThread.end?4(client)
+StorageServer.TimeoutThread.run?4()
+StorageServer.TimeoutThread?1(timeout)
+StorageServer.ZEOStorage._check_tid?5(tid, exc=None)
+StorageServer.ZEOStorage._checkread?5(oid, serial)
+StorageServer.ZEOStorage._clear_transaction?5()
+StorageServer.ZEOStorage._delete?5(oid, serial)
+StorageServer.ZEOStorage._invalidate?5(tid)
+StorageServer.ZEOStorage._pack_impl?5(time)
+StorageServer.ZEOStorage._restore?5(oid, serial, data, prev_txn)
+StorageServer.ZEOStorage._store?5(oid, serial, data, blobfile=None)
+StorageServer.ZEOStorage._undo?5(trans_id)
+StorageServer.ZEOStorage._vote?5(delay=None)
+StorageServer.ZEOStorage.blob_tempfile?7
+StorageServer.ZEOStorage.checkCurrentSerialInTransaction?4(oid, serial, id)
+StorageServer.ZEOStorage.connected?7
+StorageServer.ZEOStorage.deleteObject?4(oid, serial, id)
+StorageServer.ZEOStorage.getInvalidations?4(tid)
+StorageServer.ZEOStorage.get_info?4()
+StorageServer.ZEOStorage.get_size_info?4()
+StorageServer.ZEOStorage.history?4(tid, size=1)
+StorageServer.ZEOStorage.iterator_gc?4(iids)
+StorageServer.ZEOStorage.iterator_next?4(iid)
+StorageServer.ZEOStorage.iterator_record_next?4(iid)
+StorageServer.ZEOStorage.iterator_record_start?4(txn_iid, tid)
+StorageServer.ZEOStorage.iterator_start?4(start, stop)
+StorageServer.ZEOStorage.loadBefore?4(oid, tid)
+StorageServer.ZEOStorage.locked?7
+StorageServer.ZEOStorage.log?4(msg, level=logging.INFO, exc_info=False)
+StorageServer.ZEOStorage.log_label?7
+StorageServer.ZEOStorage.new_oids?4(n=100)
+StorageServer.ZEOStorage.notify_connected?4(conn)
+StorageServer.ZEOStorage.notify_disconnected?4()
+StorageServer.ZEOStorage.pack?4(time, wait=1)
+StorageServer.ZEOStorage.ping?4()
+StorageServer.ZEOStorage.register?4(storage_id, read_only)
+StorageServer.ZEOStorage.restorea?4(oid, serial, data, prev_txn, id)
+StorageServer.ZEOStorage.ruok?4()
+StorageServer.ZEOStorage.sendBlob?4(oid, serial)
+StorageServer.ZEOStorage.server_status?4()
+StorageServer.ZEOStorage.set_client_label?4(label)
+StorageServer.ZEOStorage.set_database?4(database)
+StorageServer.ZEOStorage.setup_delegation?4()
+StorageServer.ZEOStorage.store?4()
+StorageServer.ZEOStorage.storeBlobChunk?4(chunk)
+StorageServer.ZEOStorage.storeBlobEnd?4(oid, serial, data, id)
+StorageServer.ZEOStorage.storeBlobShared?4(oid, serial, data, filename, id)
+StorageServer.ZEOStorage.storeBlobStart?4()
+StorageServer.ZEOStorage.storea?4(oid, serial, data, id)
+StorageServer.ZEOStorage.tpc_abort?4(tid)
+StorageServer.ZEOStorage.tpc_begin?4(id, user, description, ext, tid=None, status=" ")
+StorageServer.ZEOStorage.tpc_finish?4(id)
+StorageServer.ZEOStorage.undo?4(**k)
+StorageServer.ZEOStorage.undoInfo?4(first, last, spec)
+StorageServer.ZEOStorage.undoLog?4(first, last)
+StorageServer.ZEOStorage.undoa?4(trans_id, tid)
+StorageServer.ZEOStorage.verifying?7
+StorageServer.ZEOStorage.vote?4(tid)
+StorageServer.ZEOStorage?1(server, read_only=0)
+StorageServer._addr_label?5(addr)
+StorageServer.log?4(message, level=logging.INFO, label='', exc_info=False)
+StorageServer.logger?7
+StorageServer.never_resolve_conflict?4(oid, committedSerial, oldSerial, newpickle, committedData=b'')
+StorageServer.registered_methods?7
+StorageServer.run_in_thread?4(method, *args)
+TransactionBuffer.TransactionBuffer.close?4()
+TransactionBuffer.TransactionBuffer.resolve?4(oid, data)
+TransactionBuffer.TransactionBuffer.serialnos?4(args)
+TransactionBuffer.TransactionBuffer.server_resolve?4(oid)
+TransactionBuffer.TransactionBuffer.store?4(oid, data)
+TransactionBuffer.TransactionBuffer.storeBlob?4(oid, blobfilename)
+TransactionBuffer.TransactionBuffer?1(connection_generation)
+_compat.PY32?7
+_compat.PY3?7
+_compat.PYPY?7
+_compat.Unpickler.find_class?4(modulename, name)
+_compat.Unpickler.find_global?7
+_compat.WIN?7
+_forker.DEBUG?7
+_forker.ThreadlessQueue.get?4(timeout=None)
+_forker.ThreadlessQueue.put?4(v)
+_forker.ThreadlessQueue?1()
+_forker.ZEO4_SERVER?7
+_forker.ZEOConfig.dump?4(f)
+_forker.ZEOConfig?1(addr, log=None, **options)
+_forker.debug_logging?4(logger='ZEO', stream='stderr', level=logging.DEBUG)
+_forker.logger?7
+_forker.runner?4(config, qin, qout, timeout=None, debug=False, name=None, keep=False, protocol=None)
+_forker.shutdown_zeo_server?4(stop)
+_forker.start_zeo_server?4(storage_conf=None, zeo_conf=None, port=None, keep=False, path='Data.fs', protocol=None, blob_dir=None, suicide=True, debug=False, threaded=False, start_timeout=33, name=None, log=None, show_config=False)
+_forker.stop?4()
+_forker.stop?4(stop_timeout=99)
+_forker.stop_runner?4(thread, config, qin, qout, stop_timeout=19, pid=None)
+_forker.whine?4(*message)
+asyncio.base.INET_FAMILIES?7
+asyncio.base.Protocol.call_async?4(method, args)
+asyncio.base.Protocol.call_async_iter?4(it)
+asyncio.base.Protocol.close?4()
+asyncio.base.Protocol.closed?7
+asyncio.base.Protocol.connection_made?4(transport)
+asyncio.base.Protocol.data_received?4(data)
+asyncio.base.Protocol.first_message_received?4(protocol_version)
+asyncio.base.Protocol.get_peername?4()
+asyncio.base.Protocol.getting_size?7
+asyncio.base.Protocol.got?7
+asyncio.base.Protocol.pause_writing?4()
+asyncio.base.Protocol.resume_writing?4()
+asyncio.base.Protocol.transport?7
+asyncio.base.Protocol.want?7
+asyncio.base.Protocol.write?4()
+asyncio.base.Protocol.writeit?4()
+asyncio.base.Protocol?1(loop, addr)
+asyncio.base.logger?7
+asyncio.client.Client._clear_protocols?5(protocol=None)
+asyncio.client.Client._prefetch?5(oid, tid)
+asyncio.client.Client._when_ready?5(func, result_future, *args)
+asyncio.client.Client.call_async_from_same_thread?4(method, *args)
+asyncio.client.Client.call_async_iter_threadsafe?4(future, wait_ready, it)
+asyncio.client.Client.call_async_threadsafe?4(future, wait_ready, method, args)
+asyncio.client.Client.call_threadsafe?4(future, wait_ready, method, args)
+asyncio.client.Client.close?4()
+asyncio.client.Client.close_threadsafe?4(future, _)
+asyncio.client.Client.closed?7
+asyncio.client.Client.disconnected?4(protocol=None)
+asyncio.client.Client.done?4()
+asyncio.client.Client.get_peername?4()
+asyncio.client.Client.invalidateTransaction?4(tid, oids)
+asyncio.client.Client.is_read_only?4()
+asyncio.client.Client.load_before_threadsafe?4(future, wait_ready, oid, tid)
+asyncio.client.Client.new_addrs?4(addrs)
+asyncio.client.Client.prefetch?4(future, wait_ready, oids, tid)
+asyncio.client.Client.protocol?7
+asyncio.client.Client.protocol_version?4()
+asyncio.client.Client.ready?7
+asyncio.client.Client.register_failed?4(protocol, exc)
+asyncio.client.Client.registered?4(protocol, server_tid)
+asyncio.client.Client.serialnos?4(serials)
+asyncio.client.Client.tpc_finish_threadsafe?4(future, wait_ready, tid, updates, f)
+asyncio.client.Client.try_connecting?4()
+asyncio.client.Client.trying_to_connect?4()
+asyncio.client.Client.upgrade?4(protocol)
+asyncio.client.Client.verify?4(server_tid)
+asyncio.client.Client.verify_result?7
+asyncio.client.Client?1(loop, addrs, client, cache, storage_key, read_only, connect_poll, register_failed_poll=9, ssl=None, ssl_server_hostname=None, credentials=None)
+asyncio.client.ClientRunner.apply_threadsafe?4(future, wait_ready, func, *args)
+asyncio.client.ClientRunner.async_?4(method, *args)
+asyncio.client.ClientRunner.async_iter?4(it)
+asyncio.client.ClientRunner.call?4(method, *args, **kw)
+asyncio.client.ClientRunner.call_closed?4(**k)
+asyncio.client.ClientRunner.call_future?4(method, *args)
+asyncio.client.ClientRunner.close?4()
+asyncio.client.ClientRunner.is_connected?4()
+asyncio.client.ClientRunner.is_read_only?4()
+asyncio.client.ClientRunner.load_before?4(oid, tid)
+asyncio.client.ClientRunner.new_addrs?4(addrs)
+asyncio.client.ClientRunner.prefetch?4(oids, tid)
+asyncio.client.ClientRunner.set_options?4(addrs, wrapper, cache, storage_key, read_only, timeout=30, disconnect_poll=1, **kwargs)
+asyncio.client.ClientRunner.setup_delegation?4(loop)
+asyncio.client.ClientRunner.tpc_finish?4(tid, updates, f)
+asyncio.client.ClientRunner.wait?4(timeout=None)
+asyncio.client.ClientRunner.wait_for_result?4(future, timeout)
+asyncio.client.ClientThread.close?4()
+asyncio.client.ClientThread.closed?7
+asyncio.client.ClientThread.exception?7
+asyncio.client.ClientThread.run?4()
+asyncio.client.ClientThread?1(addrs, client, cache, storage_key='1', read_only=False, timeout=30, disconnect_poll=1, ssl=None, ssl_server_hostname=None, credentials=None)
+asyncio.client.Fallback?7
+asyncio.client.Fut.add_done_callback?4(cb)
+asyncio.client.Fut.exc?7
+asyncio.client.Fut.result?4()
+asyncio.client.Fut.set_exception?4(exc)
+asyncio.client.Fut.set_result?4(result)
+asyncio.client.Protocol.call?4(future, method, args)
+asyncio.client.Protocol.client_delegated?7
+asyncio.client.Protocol.client_methods?7
+asyncio.client.Protocol.close?4()
+asyncio.client.Protocol.connect?4()
+asyncio.client.Protocol.connection_lost?4(exc)
+asyncio.client.Protocol.connection_made?4(transport)
+asyncio.client.Protocol.done_connecting?4()
+asyncio.client.Protocol.exception_type_type?7
+asyncio.client.Protocol.finish_connect?4(protocol_version)
+asyncio.client.Protocol.fut?4(method, *args)
+asyncio.client.Protocol.heartbeat?4(write=True)
+asyncio.client.Protocol.load_before?4(oid, tid)
+asyncio.client.Protocol.message_id?7
+asyncio.client.Protocol.message_received?4(data)
+asyncio.client.Protocol.pop_futures?4()
+asyncio.client.Protocol.protocol_factory?4()
+asyncio.client.Protocol.protocols?7
+asyncio.client.Protocol?1(loop, addr, client, storage_key, read_only, connect_poll=1, heartbeat_interval=60, ssl=None, ssl_server_hostname=None, credentials=None)
+asyncio.client._?5(future)
+asyncio.client.call_generator?4(*args, **kw)
+asyncio.client.create_BTreesConflictError?4(class_, args)
+asyncio.client.create_ConflictError?4(class_, args)
+asyncio.client.create_Exception?4(class_, args)
+asyncio.client.create_MultipleUndoErrors?4(class_, args)
+asyncio.client.exc_classes?7
+asyncio.client.exc_factories?7
+asyncio.client.future_generator?4(func)
+asyncio.client.local_random?7
+asyncio.client.logger?7
+asyncio.client.store?4(gen, future)
+asyncio.client.unlogged_exceptions?7
+asyncio.mtacceptor.Acceptor._open_socket?5()
+asyncio.mtacceptor.Acceptor.close?4()
+asyncio.mtacceptor.Acceptor.handle_accept?4()
+asyncio.mtacceptor.Acceptor.loop?4(timeout=30.0)
+asyncio.mtacceptor.Acceptor.make_ssl_transport?4(**kw)
+asyncio.mtacceptor.Acceptor.readable?4()
+asyncio.mtacceptor.Acceptor.run?4()
+asyncio.mtacceptor.Acceptor.writable?4()
+asyncio.mtacceptor.Acceptor?1(storage_server, addr, ssl, msgpack)
+asyncio.mtacceptor.logger?7
+asyncio.server.Acceptor._close?5()
+asyncio.server.Acceptor.close?4()
+asyncio.server.Acceptor.closed?7
+asyncio.server.Acceptor.factory?4()
+asyncio.server.Acceptor.loop?4(timeout=None)
+asyncio.server.Acceptor.server_closed?4()
+asyncio.server.Acceptor.timeout?4()
+asyncio.server.Acceptor?1(storage_server, addr, ssl, msgpack)
+asyncio.server.Delay.error?4(exc_info)
+asyncio.server.Delay.msgid?7
+asyncio.server.Delay.reply?4(obj)
+asyncio.server.Delay.set_sender?4(msgid, protocol)
+asyncio.server.MTDelay.error?4(exc_info)
+asyncio.server.MTDelay.reply?4(obj)
+asyncio.server.MTDelay.set_sender?4(*args)
+asyncio.server.MTDelay?1()
+asyncio.server.Result.set_sender?4(msgid, protocol)
+asyncio.server.Result?1(*args)
+asyncio.server.ServerProtocol.async_?4(method, *args)
+asyncio.server.ServerProtocol.async_threadsafe?4(method, *args)
+asyncio.server.ServerProtocol.call_soon_threadsafe?4(func, *args)
+asyncio.server.ServerProtocol.close?4()
+asyncio.server.ServerProtocol.closed?7
+asyncio.server.ServerProtocol.connected?7
+asyncio.server.ServerProtocol.connection_lost?4(exc)
+asyncio.server.ServerProtocol.connection_made?4(transport)
+asyncio.server.ServerProtocol.finish_connect?4(protocol_version)
+asyncio.server.ServerProtocol.message_received?4(message)
+asyncio.server.ServerProtocol.methods?7
+asyncio.server.ServerProtocol.name?7
+asyncio.server.ServerProtocol.protocols?7
+asyncio.server.ServerProtocol.send_error?4(message_id, exc, send_error=False)
+asyncio.server.ServerProtocol.send_reply?4(message_id, result, send_error=False, flag=0)
+asyncio.server.ServerProtocol.send_reply_threadsafe?4(message_id, result)
+asyncio.server.ServerProtocol.stop?4()
+asyncio.server.ServerProtocol.unlogged_exception_types?7
+asyncio.server.ServerProtocol?1(loop, addr, zeo_storage, msgpack)
+asyncio.server.best_protocol_version?7
+asyncio.server.logger?7
+asyncio.server.new_connection?4(loop, addr, socket, zeo_storage, msgpack)
+asyncio.testing.AsyncRPC?1(api)
+asyncio.testing.ClientRunner.async_?7
+asyncio.testing.ClientRunner.call?4(method, *args, **kw)
+asyncio.testing.ClientRunner.close?4()
+asyncio.testing.ClientRunner.start?4(wait=True)
+asyncio.testing.ClientRunner.wait?4(timeout=None)
+asyncio.testing.ClientRunner?1(addr, client, cache, storage, read_only, timeout, **kw)
+asyncio.testing.Handle.cancel?4()
+asyncio.testing.Handle.cancelled?7
+asyncio.testing.Loop._connect?5(future, protocol_factory)
+asyncio.testing.Loop.call_exception_handler?4(context)
+asyncio.testing.Loop.call_later?4(delay, func, *args)
+asyncio.testing.Loop.call_soon?4(func, *args, **kw)
+asyncio.testing.Loop.call_soon_threadsafe?4(func, *args)
+asyncio.testing.Loop.close?4()
+asyncio.testing.Loop.closed?7
+asyncio.testing.Loop.connect_connecting?4(addr)
+asyncio.testing.Loop.create_connection?4(protocol_factory, host=None, port=None, sock=None, ssl=None, server_hostname=None)
+asyncio.testing.Loop.create_unix_connection?4(protocol_factory, path)
+asyncio.testing.Loop.fail_connecting?4(addr)
+asyncio.testing.Loop.protocol?7
+asyncio.testing.Loop.stop?4()
+asyncio.testing.Loop.stopped?7
+asyncio.testing.Loop?1(addrs=(), debug=True)
+asyncio.testing.Transport.capacity?7
+asyncio.testing.Transport.check_pause?4()
+asyncio.testing.Transport.check_resume?4()
+asyncio.testing.Transport.close?4()
+asyncio.testing.Transport.closed?7
+asyncio.testing.Transport.extra?7
+asyncio.testing.Transport.get_extra_info?4(name)
+asyncio.testing.Transport.paused?7
+asyncio.testing.Transport.pop?4(count=None)
+asyncio.testing.Transport.write?4(data)
+asyncio.testing.Transport.writelines?4(lines)
+asyncio.testing.Transport?1(protocol)
+asyncio.tests.Base.enc?7
+asyncio.tests.Base.parse?4(data)
+asyncio.tests.Base.pop?4(count=None, parse=True)
+asyncio.tests.Base.send?4(method, *args, **kw)
+asyncio.tests.Base.seq_type?7
+asyncio.tests.Base.setUp?4()
+asyncio.tests.Base.target?7
+asyncio.tests.Base.unsized?4(data, unpickle=False)
+asyncio.tests.ClientTests.finished_cb?4()
+asyncio.tests.ClientTests.maxDiff?7
+asyncio.tests.ClientTests.respond?4(message_id, result, async_=False)
+asyncio.tests.ClientTests.start?4(addrs=(('127.0.0.1', 8200), ), loop_addrs=None, read_only=False, finish_start=False, )
+asyncio.tests.ClientTests.tearDown?4()
+asyncio.tests.ClientTests.testClientBasics?4()
+asyncio.tests.ClientTests.test_ClientDisconnected_on_call_timeout?4()
+asyncio.tests.ClientTests.test_bad_protocol?4()
+asyncio.tests.ClientTests.test_bad_server_tid?4()
+asyncio.tests.ClientTests.test_cache_behind?4()
+asyncio.tests.ClientTests.test_cache_way_behind?4()
+asyncio.tests.ClientTests.test_call_async_from_same_thread?4()
+asyncio.tests.ClientTests.test_errors_in_data_received?4()
+asyncio.tests.ClientTests.test_flow_control?4()
+asyncio.tests.ClientTests.test_get_peername?4()
+asyncio.tests.ClientTests.test_heartbeat?4()
+asyncio.tests.ClientTests.test_invalidations_while_verifying?4()
+asyncio.tests.ClientTests.test_multiple_addresses?4()
+asyncio.tests.ClientTests.test_readonly_fallback?4()
+asyncio.tests.ClientTests.wait_for_result?4(future, timeout)
+asyncio.tests.Logging?1(level=logging.ERROR)
+asyncio.tests.MemoryCache.clear?7
+asyncio.tests.MemoryCache.close?4()
+asyncio.tests.MemoryCache.closed?7
+asyncio.tests.MemoryCache.getLastTid?4()
+asyncio.tests.MemoryCache.invalidate?4(oid, tid)
+asyncio.tests.MemoryCache.load?4(oid)
+asyncio.tests.MemoryCache.loadBefore?4(oid, tid)
+asyncio.tests.MemoryCache.setLastTid?4(tid)
+asyncio.tests.MemoryCache.store?4(oid, start_tid, end_tid, data)
+asyncio.tests.MemoryCache?1()
+asyncio.tests.MsgpackClientTests.enc?7
+asyncio.tests.MsgpackClientTests.seq_type?7
+asyncio.tests.MsgpackServerTests.enc?7
+asyncio.tests.MsgpackServerTests.seq_type?7
+asyncio.tests.ServerTests.call?4(meth, *args, **kw)
+asyncio.tests.ServerTests.connect?4(finish=False)
+asyncio.tests.ServerTests.message_id?7
+asyncio.tests.ServerTests.target?7
+asyncio.tests.ServerTests.testServerBasics?4()
+asyncio.tests.ServerTests.test_invalid_methods?4()
+asyncio.tests.response?4(*data)
+asyncio.tests.server_protocol?4(msgpack, zeo_storage=None, protocol_version=None, addr=('1.2.3.4', '42'), )
+asyncio.tests.sized?4(message)
+asyncio.tests.test_suite?4()
+cache.ClientCache._del_noncurrent?5(oid, tid)
+cache.ClientCache._initfile?5(fsize)
+cache.ClientCache._makeroom?5(nbytes)
+cache.ClientCache._set_noncurrent?5(oid, tid, ofs)
+cache.ClientCache._setup_trace?5(path)
+cache.ClientCache._store?5(oid, start_tid, end_tid, data, size)
+cache.ClientCache._trace?5(oid=b"", tid=z64, end_tid=z64, dlen=0)
+cache.ClientCache._tracefile?8
+cache.ClientCache._unsetup_trace?5()
+cache.ClientCache.clear?4()
+cache.ClientCache.clearStats?4()
+cache.ClientCache.close?4()
+cache.ClientCache.contents?4()
+cache.ClientCache.dump?4()
+cache.ClientCache.fc?4()
+cache.ClientCache.getLastTid?4()
+cache.ClientCache.getStats?4()
+cache.ClientCache.invalidate?4(oid, tid)
+cache.ClientCache.load?4(oid, before_tid=None)
+cache.ClientCache.loadBefore?4(oid, before_tid)
+cache.ClientCache.setLastTid?4(tid)
+cache.ClientCache.store?4(oid, start_tid, end_tid, data)
+cache.ClientCache?1(path=None, size=200*1024**2, rearrange=.8)
+cache.ZEC_HEADER_SIZE?7
+cache._current_index_type?8
+cache._noncurrent_bucket_type?8
+cache._noncurrent_index_type?8
+cache.allocated_record_overhead?7
+cache.logger?7
+cache.magic?7
+cache.max_block_size?7
+cache.sync?4(f)
+interfaces.IClientCache.clear?4()
+interfaces.IClientCache.close?4()
+interfaces.IClientCache.getLastTid?4()
+interfaces.IClientCache.invalidate?4(tid)
+interfaces.IClientCache.load?4()
+interfaces.IClientCache.loadBefore?4(tid)
+interfaces.IClientCache.setLastTid?4()
+interfaces.IClientCache.store?4(start_tid, end_tid, data)
+interfaces.IServeable.lastInvalidations?4()
+interfaces.IServeable.tpc_transaction?4()
+interfaces.StaleCache?1(storage)
+monitor.StorageStats.clients?4()
+monitor.StorageStats.dump?4(f)
+monitor.StorageStats.parse?4(s)
+monitor.StorageStats?1(connections=None)
+monitor.zeo_version?7
+nagios.NO_TRANSACTION?7
+nagios.check?4(addr, output_metrics, status, per)
+nagios.diff_names?7
+nagios.error?4(message)
+nagios.main?4(args=None)
+nagios.new_metric?4(metrics, storage_id, name, value)
+nagios.nodiff_names?7
+nagios.per_times?7
+nagios.result?4(messages, metrics=(), status=None)
+nagios.warn?4(message)
+runzeo.FSConfig.getSectionName?4()
+runzeo.FSConfig?1(name, path)
+runzeo.ZEOOptions.logsectionname?7
+runzeo.ZEOOptions.realize?4(*a, **k)
+runzeo.ZEOOptions.schemadir?7
+runzeo.ZEOOptions?1()
+runzeo.ZEOOptionsMixin.add_zeo_options?4()
+runzeo.ZEOOptionsMixin.handle_address?4(arg)
+runzeo.ZEOOptionsMixin.handle_filename?4(arg)
+runzeo.ZEOOptionsMixin.handle_test?4(*args)
+runzeo.ZEOOptionsMixin.storages?7
+runzeo.ZEOOptionsMixin.testing_exit_immediately?7
+runzeo.ZEOServer._get_pidfile?5()
+runzeo.ZEOServer.can_connect?4(family, address)
+runzeo.ZEOServer.check_socket?4()
+runzeo.ZEOServer.clear_socket?4()
+runzeo.ZEOServer.close_server?4()
+runzeo.ZEOServer.create_server?4()
+runzeo.ZEOServer.handle_sighup?4()
+runzeo.ZEOServer.handle_sigint?4()
+runzeo.ZEOServer.handle_sigterm?4()
+runzeo.ZEOServer.handle_sigusr2?4()
+runzeo.ZEOServer.loop_forever?4()
+runzeo.ZEOServer.main?4()
+runzeo.ZEOServer.make_pidfile?4()
+runzeo.ZEOServer.open_storages?4()
+runzeo.ZEOServer.remove_pidfile?4()
+runzeo.ZEOServer.setup_default_logging?4()
+runzeo.ZEOServer.setup_signals?4()
+runzeo.ZEOServer.setup_win32_signals?4()
+runzeo.ZEOServer.wrapper?4(frame_dummy, method=method)
+runzeo.ZEOServer?1(options)
+runzeo._pid?8
+runzeo.create_server?4(storages, options)
+runzeo.init_signames?4()
+runzeo.log?4(msg, level=logging.INFO, exc_info=False)
+runzeo.logger?7
+runzeo.main?4(args=None)
+runzeo.parse_binding_address?4(arg)
+runzeo.run?4(args)
+runzeo.signame?4(sig)
+runzeo.signames?7
+runzeo.windows_shutdown_handler?4()
+scripts.cache_simul.CircularCacheEntry?1(key, end_tid, offset)
+scripts.cache_simul.CircularCacheSimulation._remove?5(oid, tid)
+scripts.cache_simul.CircularCacheSimulation._remove_noncurrent_revisions?5(oid)
+scripts.cache_simul.CircularCacheSimulation.add?4(oid, size, start_tid, end_tid=z64)
+scripts.cache_simul.CircularCacheSimulation.check?4()
+scripts.cache_simul.CircularCacheSimulation.dump?4()
+scripts.cache_simul.CircularCacheSimulation.evicted_hit?7
+scripts.cache_simul.CircularCacheSimulation.evicts?7
+scripts.cache_simul.CircularCacheSimulation.extras?7
+scripts.cache_simul.CircularCacheSimulation.inval?4(oid, tid)
+scripts.cache_simul.CircularCacheSimulation.load?4(oid, size, tid, code)
+scripts.cache_simul.CircularCacheSimulation.makeroom?4(need)
+scripts.cache_simul.CircularCacheSimulation.report?4()
+scripts.cache_simul.CircularCacheSimulation.restart?4()
+scripts.cache_simul.CircularCacheSimulation.write?4(oid, size, start_tid, end_tid, evhit=0)
+scripts.cache_simul.CircularCacheSimulation?1(cachelimit, rearrange)
+scripts.cache_simul.Simulation.event?4(ts, dlen, _version, code, oid, start_tid, end_tid)
+scripts.cache_simul.Simulation.extraheader?4()
+scripts.cache_simul.Simulation.extraname?7
+scripts.cache_simul.Simulation.finish?4()
+scripts.cache_simul.Simulation.format?7
+scripts.cache_simul.Simulation.inval?4(oid, start_tid)
+scripts.cache_simul.Simulation.load?4(oid, size, start_tid, code)
+scripts.cache_simul.Simulation.nreports?7
+scripts.cache_simul.Simulation.printheader?4()
+scripts.cache_simul.Simulation.report?4()
+scripts.cache_simul.Simulation.restart?4()
+scripts.cache_simul.Simulation.write?4(oid, size, start_tid, end_tid)
+scripts.cache_simul.Simulation?1(cachelimit, rearrange)
+scripts.cache_simul.addcommas?4(n)
+scripts.cache_simul.duration?4(secs)
+scripts.cache_simul.hitrate?4(loads, hits)
+scripts.cache_simul.main?4(args=None)
+scripts.cache_simul.maybe?4(f, p=0.5)
+scripts.cache_simul.nre?7
+scripts.cache_simul.roundup?4(size)
+scripts.cache_stats.GzipFileType?1()
+scripts.cache_stats.U64?4(s)
+scripts.cache_stats._interval?5(a)
+scripts.cache_stats.add_interval_argument?4(parser)
+scripts.cache_stats.add_tracefile_argument?4(parser)
+scripts.cache_stats.addcommas?4(n)
+scripts.cache_stats.dumpbyinterval?4(byinterval, h0, he)
+scripts.cache_stats.dumpbysize?4(bysize, how, how2)
+scripts.cache_stats.explain?7
+scripts.cache_stats.histogram?4(d)
+scripts.cache_stats.hitrate?4(bycode)
+scripts.cache_stats.main?4(args=None)
+scripts.cache_stats.oid_repr?4(oid)
+scripts.parsezeolog.TStats.counter?7
+scripts.parsezeolog.TStats.fields?7
+scripts.parsezeolog.TStats.fmt?7
+scripts.parsezeolog.TStats.hdr?7
+scripts.parsezeolog.TStats.report?4()
+scripts.parsezeolog.TStats?1()
+scripts.parsezeolog.TransactionParser.get_txn?4(args)
+scripts.parsezeolog.TransactionParser.get_txns?4()
+scripts.parsezeolog.TransactionParser.parse?4(line)
+scripts.parsezeolog.TransactionParser.tpc_begin?4(time, args)
+scripts.parsezeolog.TransactionParser.tpc_finish?4(time, args)
+scripts.parsezeolog.TransactionParser.vote?4(time, args)
+scripts.parsezeolog.TransactionParser?1()
+scripts.parsezeolog.parse_line?4(line)
+scripts.parsezeolog.parse_method?4(line)
+scripts.parsezeolog.parse_time?4(line)
+scripts.parsezeolog.rx_meth?7
+scripts.parsezeolog.rx_time?7
+scripts.tests.test_suite?4()
+scripts.timeout.ZERO?7
+scripts.timeout.main?4()
+scripts.zeopack.WAIT?7
+scripts.zeopack._main?5(args=None, prog=None)
+scripts.zeopack.error?4(message)
+scripts.zeopack.main?4(*args)
+scripts.zeopack.usage?7
+scripts.zeoqueue.COMMASPACE?7
+scripts.zeoqueue.PROGRAM?7
+scripts.zeoqueue.STATEFILE?7
+scripts.zeoqueue.Status.call_tpc_abort?4(t, client, tid, rest)
+scripts.zeoqueue.Status.call_tpc_begin?4(t, client, tid, rest)
+scripts.zeoqueue.Status.call_tpc_finish?4(t, client, tid, rest)
+scripts.zeoqueue.Status.call_vote?4(t, client, tid, rest)
+scripts.zeoqueue.Status.iscomplete?4()
+scripts.zeoqueue.Status.process?4(line)
+scripts.zeoqueue.Status.process_block?4(line)
+scripts.zeoqueue.Status.process_call?4(line)
+scripts.zeoqueue.Status.process_connect?4(line)
+scripts.zeoqueue.Status.process_file?4(fp)
+scripts.zeoqueue.Status.process_start?4(line)
+scripts.zeoqueue.Status.report?4()
+scripts.zeoqueue.Status.reset?4()
+scripts.zeoqueue.Status?1()
+scripts.zeoqueue.Txn.isactive?4()
+scripts.zeoqueue.Txn?1(tid)
+scripts.zeoqueue.ccre?7
+scripts.zeoqueue.main?4()
+scripts.zeoqueue.parse_time?4(line)
+scripts.zeoqueue.tcre?7
+scripts.zeoqueue.usage?4(code, msg='')
+scripts.zeoqueue.wcre?7
+scripts.zeoreplay.ReplayTxn.replay?4()
+scripts.zeoreplay.ReplayTxn?1(storage)
+scripts.zeoreplay.StoreStat?1(when, oid, size)
+scripts.zeoreplay.TxnStat.storea?4(when, args, client)
+scripts.zeoreplay.TxnStat.tpc_abort?4(when)
+scripts.zeoreplay.TxnStat.tpc_begin?4(when, args, client)
+scripts.zeoreplay.TxnStat.tpc_finish?4(when)
+scripts.zeoreplay.TxnStat?1()
+scripts.zeoreplay.ZEOParser.parse?4(line)
+scripts.zeoreplay.ZEOParser.replay?4()
+scripts.zeoreplay.ZEOParser.report?4(txn)
+scripts.zeoreplay.ZEOParser.storea?4(when, args, client)
+scripts.zeoreplay.ZEOParser.tpc_begin?4(when, args, client)
+scripts.zeoreplay.ZEOParser.tpc_finish?4(when, args, client)
+scripts.zeoreplay.ZEOParser?1(maxtxns=-1, report=1, storage=None)
+scripts.zeoreplay._revids?8
+scripts.zeoreplay.datecre?7
+scripts.zeoreplay.main?4()
+scripts.zeoreplay.methcre?7
+scripts.zeoreplay.parse_line?4(line)
+scripts.zeoreplay.parse_time?4(line)
+scripts.zeoreplay.usage?4(code, msg='')
+scripts.zeoserverlog.blocked_times?4(args)
+scripts.zeoserverlog.connidre?7
+scripts.zeoserverlog.day?4(f)
+scripts.zeoserverlog.days?4(f)
+scripts.zeoserverlog.hour?4(f)
+scripts.zeoserverlog.hours?4(f)
+scripts.zeoserverlog.idre?7
+scripts.zeoserverlog.minute?4(f, slice=16, detail=1, summary=1)
+scripts.zeoserverlog.minutes?4(f)
+scripts.zeoserverlog.new_connection_idre?7
+scripts.zeoserverlog.newobre?7
+scripts.zeoserverlog.recovery?4(f)
+scripts.zeoserverlog.stats?4(s)
+scripts.zeoserverlog.sub?4(t1, t2)
+scripts.zeoserverlog.time?4(line)
+scripts.zeoserverlog.time_calls?4(f)
+scripts.zeoserverlog.time_tpc?4(f)
+scripts.zeoserverlog.time_trans?4(f)
+scripts.zeoserverlog.verify?4(f)
+scripts.zeoserverlog.waitre?7
+scripts.zeoserverlog.xopen?4(f)
+scripts.zeoup.ZEO_VERSION?7
+scripts.zeoup.check_server?4(addr, storage, write)
+scripts.zeoup.main?4()
+scripts.zeoup.setup_logging?4()
+scripts.zeoup.usage?4(exit=1)
+shortrepr.REPR_LIMIT?7
+shortrepr.short_repr?4(obj)
+tests.Cache.TransUndoStorageWithCache.checkUndoInvalidation?4()
+tests.CommitLockTests.CommitLockTests.NUM_CLIENTS?7
+tests.CommitLockTests.CommitLockTests._begin_threads?5()
+tests.CommitLockTests.CommitLockTests._cleanup?5()
+tests.CommitLockTests.CommitLockTests._duplicate_client?5()
+tests.CommitLockTests.CommitLockTests._finish_threads?5()
+tests.CommitLockTests.CommitLockTests._get_timestamp?5()
+tests.CommitLockTests.CommitLockTests._start_txn?5()
+tests.CommitLockTests.CommitLockVoteTests.checkCommitLockVoteAbort?4()
+tests.CommitLockTests.CommitLockVoteTests.checkCommitLockVoteClose?4()
+tests.CommitLockTests.CommitLockVoteTests.checkCommitLockVoteFinish?4()
+tests.CommitLockTests.DummyDB.invalidate?4(*args, **kwargs)
+tests.CommitLockTests.DummyDB.transform_record_data?7
+tests.CommitLockTests.WorkerThread.myvote?4()
+tests.CommitLockTests.WorkerThread.testrun?4()
+tests.CommitLockTests.WorkerThread?1(test, storage, trans)
+tests.CommitLockTests.ZERO?7
+tests.ConnectionTests.CommonSetupTearDown._client_options?5()
+tests.ConnectionTests.CommonSetupTearDown._getAddr?5()
+tests.ConnectionTests.CommonSetupTearDown._newAddr?5()
+tests.ConnectionTests.CommonSetupTearDown.cache_id?7
+tests.ConnectionTests.CommonSetupTearDown.db_class?7
+tests.ConnectionTests.CommonSetupTearDown.getConfig?4(path, create, read_only)
+tests.ConnectionTests.CommonSetupTearDown.getServerConfig?4(addr, ro_svr)
+tests.ConnectionTests.CommonSetupTearDown.invq?7
+tests.ConnectionTests.CommonSetupTearDown.keep?7
+tests.ConnectionTests.CommonSetupTearDown.openClientStorage?4(cache=None, cache_size=200000, wait=1, read_only=0, read_only_fallback=0, username=None, password=None, realm=None)
+tests.ConnectionTests.CommonSetupTearDown.pollDown?4(timeout=30.0)
+tests.ConnectionTests.CommonSetupTearDown.pollUp?4(timeout=30.0, storage=None)
+tests.ConnectionTests.CommonSetupTearDown.setUp?4(before=None)
+tests.ConnectionTests.CommonSetupTearDown.shutdownServer?4(index=0)
+tests.ConnectionTests.CommonSetupTearDown.startServer?4(create=1, index=0, read_only=0, ro_svr=0, keep=None, path=None, **kw)
+tests.ConnectionTests.CommonSetupTearDown.tearDown?4()
+tests.ConnectionTests.CommonSetupTearDown.timeout?7
+tests.ConnectionTests.ConnectionTests.NOcheckMultiStorageTransaction?4()
+tests.ConnectionTests.ConnectionTests._bad_message?5(msg)
+tests.ConnectionTests.ConnectionTests.checkBadMessage1?4()
+tests.ConnectionTests.ConnectionTests.checkBadMessage2?4()
+tests.ConnectionTests.ConnectionTests.checkBasicPersistence?4()
+tests.ConnectionTests.ConnectionTests.checkCheckForOutOfDateServer?4()
+tests.ConnectionTests.ConnectionTests.checkCrossDBInvalidations?4()
+tests.ConnectionTests.ConnectionTests.checkDisconnectedCacheFails?4()
+tests.ConnectionTests.ConnectionTests.checkDisconnectedCacheWorks?4()
+tests.ConnectionTests.ConnectionTests.checkDisconnectionError?4()
+tests.ConnectionTests.ConnectionTests.checkMultipleAddresses?4()
+tests.ConnectionTests.ConnectionTests.checkReadOnlyClient?4()
+tests.ConnectionTests.ConnectionTests.checkReadOnlyFallbackReadOnlyServer?4()
+tests.ConnectionTests.ConnectionTests.checkReadOnlyFallbackWritable?4()
+tests.ConnectionTests.ConnectionTests.checkReadOnlyServer?4()
+tests.ConnectionTests.ConnectionTests.checkVerificationInvalidationPersists?4()
+tests.ConnectionTests.ConnectionTests.write?4()
+tests.ConnectionTests.DummyDB.invalidate?4(*args, **kwargs)
+tests.ConnectionTests.DummyDB.invalidateCache?4()
+tests.ConnectionTests.DummyDB.transform_record_data?7
+tests.ConnectionTests.InvqTests.checkQuickVerificationWith2Clients?4()
+tests.ConnectionTests.InvqTests.checkVerificationWith2ClientsInvqOverflow?4()
+tests.ConnectionTests.InvqTests.invq?7
+tests.ConnectionTests.MSTThread.closeclients?4()
+tests.ConnectionTests.MSTThread.run?4()
+tests.ConnectionTests.MSTThread?1(testcase, name)
+tests.ConnectionTests.ReconnectionTests.checkDisconnectedAbort?4()
+tests.ConnectionTests.ReconnectionTests.checkMultipleServers?4()
+tests.ConnectionTests.ReconnectionTests.checkNoVerificationOnServerRestart?4()
+tests.ConnectionTests.ReconnectionTests.checkNoVerificationOnServerRestartWith2Clients?4()
+tests.ConnectionTests.ReconnectionTests.checkReadOnlyFallbackReadOnlyStorage?4()
+tests.ConnectionTests.ReconnectionTests.checkReadOnlyStorage?4()
+tests.ConnectionTests.ReconnectionTests.checkReconnectFallback?4()
+tests.ConnectionTests.ReconnectionTests.checkReconnectReadOnly?4()
+tests.ConnectionTests.ReconnectionTests.checkReconnectSwitch?4()
+tests.ConnectionTests.ReconnectionTests.checkReconnectUpgrade?4()
+tests.ConnectionTests.ReconnectionTests.checkReconnectWritable?4()
+tests.ConnectionTests.ReconnectionTests.checkReconnection?4()
+tests.ConnectionTests.ReconnectionTests.invq?7
+tests.ConnectionTests.ReconnectionTests.keep?7
+tests.ConnectionTests.SSLConnectionTests._client_options?5()
+tests.ConnectionTests.SSLConnectionTests.getServerConfig?4(addr, ro_svr)
+tests.ConnectionTests.TestClientStorage.connection_count_for_tests?7
+tests.ConnectionTests.TestClientStorage.notify_connected?4(conn, info)
+tests.ConnectionTests.TestClientStorage.test_connection?7
+tests.ConnectionTests.TimeoutTests.checkTimeout?4()
+tests.ConnectionTests.TimeoutTests.checkTimeoutAfterVote?4()
+tests.ConnectionTests.TimeoutTests.checkTimeoutOnAbort?4()
+tests.ConnectionTests.TimeoutTests.checkTimeoutOnAbortNoLock?4()
+tests.ConnectionTests.TimeoutTests.timeout?7
+tests.ConnectionTests.V6Setup._getAddr?5()
+tests.ConnectionTests.ZERO?7
+tests.ConnectionTests.logger?7
+tests.ConnectionTests.short_timeout?4(self)
+tests.InvalidationTests.FailableThread.testrun?4()
+tests.InvalidationTests.InvalidationTests.MAXTIME?7
+tests.InvalidationTests.InvalidationTests.MINTIME?7
+tests.InvalidationTests.InvalidationTests.StressThread?7
+tests.InvalidationTests.InvalidationTests._check_threads?5(tree, *threads)
+tests.InvalidationTests.InvalidationTests._check_tree?5(cn, tree)
+tests.InvalidationTests.InvalidationTests.checkConcurrentLargeUpdates?4()
+tests.InvalidationTests.InvalidationTests.checkConcurrentUpdates19Storages?4()
+tests.InvalidationTests.InvalidationTests.checkConcurrentUpdates1Storage?4()
+tests.InvalidationTests.InvalidationTests.checkConcurrentUpdates2Storages?4()
+tests.InvalidationTests.InvalidationTests.checkConcurrentUpdates2StoragesMT?4()
+tests.InvalidationTests.InvalidationTests.checkConcurrentUpdates2Storages_emulated?4()
+tests.InvalidationTests.InvalidationTests.go?4(stop, commitdict, *threads)
+tests.InvalidationTests.LargeUpdatesThread._testrun?5()
+tests.InvalidationTests.LargeUpdatesThread?1(test, db, stop, threadnum, commitdict, startnum, step=2, sleep=None)
+tests.InvalidationTests.StressTask.cleanup?4()
+tests.InvalidationTests.StressTask.commit?4()
+tests.InvalidationTests.StressTask.doStep?4()
+tests.InvalidationTests.StressTask?1(db, threadnum, startnum, step=2, sleep=None)
+tests.InvalidationTests.StressThread._testrun?5()
+tests.InvalidationTests.StressThread?1(testcase, db, stop, threadnum, commitdict, startnum, step=2, sleep=None)
+tests.InvalidationTests._runTasks?5(rounds, *tasks)
+tests.InvalidationTests.commit?4(run, actions)
+tests.IterationTests.IterationTests._assertIteratorIdsEmpty?5()
+tests.IterationTests.IterationTests.checkIteratorExhaustionStorage?4()
+tests.IterationTests.IterationTests.checkIteratorGCProtocol?4()
+tests.IterationTests.IterationTests.checkIteratorGCSpanTransactions?4()
+tests.IterationTests.IterationTests.checkIteratorGCStorageCommitting?4()
+tests.IterationTests.IterationTests.checkIteratorGCStorageDisconnect?4()
+tests.IterationTests.IterationTests.checkIteratorGCStorageTPCAborting?4()
+tests.IterationTests.IterationTests.checkIteratorParallel?4()
+tests.IterationTests.iterator_sane_after_reconnect?4()
+tests.TestThread.TestThread.cleanup?4(timeout=15)
+tests.TestThread.TestThread.run?4()
+tests.TestThread.TestThread?1(testcase)
+tests.ThreadTests.BasicThread.join?4()
+tests.ThreadTests.BasicThread?1(storage, doNextEvent, threadStartedEvent)
+tests.ThreadTests.GetsThroughBeginThread.run?4()
+tests.ThreadTests.GetsThroughVoteThread.run?4()
+tests.ThreadTests.ThreadTests.checkDisconnectedOnThread2Close?4()
+tests.ThreadTests.ThreadTests.checkMTStores?4()
+tests.ThreadTests.ThreadTests.checkSecondBeginFails?4()
+tests.ThreadTests.ThreadTests.mtstorehelper?4()
+tests.ThreadTests.ZERO?7
+tests.ZEO4.StorageServer.ClientStub.beginVerify?4()
+tests.ZEO4.StorageServer.ClientStub.endVerify?4()
+tests.ZEO4.StorageServer.ClientStub.info?4(arg)
+tests.ZEO4.StorageServer.ClientStub.invalidateTransaction?4(tid, args)
+tests.ZEO4.StorageServer.ClientStub.invalidateVerify?4(args)
+tests.ZEO4.StorageServer.ClientStub.serialnos?4(arg)
+tests.ZEO4.StorageServer.ClientStub.store?4()
+tests.ZEO4.StorageServer.ClientStub.storeBlob?4(oid, serial, blobfilename)
+tests.ZEO4.StorageServer.ClientStub308.invalidateTransaction?4(tid, args)
+tests.ZEO4.StorageServer.ClientStub308.invalidateVerify?4(oid)
+tests.ZEO4.StorageServer.ClientStub?1(rpc)
+tests.ZEO4.StorageServer.CommitLog.checkread?4(oid, serial)
+tests.ZEO4.StorageServer.CommitLog.close?4()
+tests.ZEO4.StorageServer.CommitLog.delete?4(oid, serial)
+tests.ZEO4.StorageServer.CommitLog.restore?4(oid, serial, data, prev_txn)
+tests.ZEO4.StorageServer.CommitLog.size?4()
+tests.ZEO4.StorageServer.CommitLog.store?4(oid, serial, data)
+tests.ZEO4.StorageServer.CommitLog.undo?4(transaction_id)
+tests.ZEO4.StorageServer.CommitLog?1()
+tests.ZEO4.StorageServer.ResolvedSerial?7
+tests.ZEO4.StorageServer.ServerEvent?1(server, **kw)
+tests.ZEO4.StorageServer.SlowMethodThread.run?4()
+tests.ZEO4.StorageServer.SlowMethodThread?1(method, args)
+tests.ZEO4.StorageServer.StorageServer.ManagedServerConnectionClass?7
+tests.ZEO4.StorageServer.StorageServer.ZEOStorageClass?7
+tests.ZEO4.StorageServer.StorageServer._invalidateCache?5(storage_id)
+tests.ZEO4.StorageServer.StorageServer._setup_auth?5(protocol)
+tests.ZEO4.StorageServer.StorageServer._setup_invq?5(name, storage)
+tests.ZEO4.StorageServer.StorageServer.already_waiting?4(zeostore)
+tests.ZEO4.StorageServer.StorageServer.close?4(join_timeout=1)
+tests.ZEO4.StorageServer.StorageServer.close_conn?4(conn)
+tests.ZEO4.StorageServer.StorageServer.get_invalidations?4(storage_id, tid)
+tests.ZEO4.StorageServer.StorageServer.invalidate?4(conn, storage_id, tid, invalidated=(), info=None)
+tests.ZEO4.StorageServer.StorageServer.lock_storage?4(zeostore, delay)
+tests.ZEO4.StorageServer.StorageServer.loop?4(timeout=30)
+tests.ZEO4.StorageServer.StorageServer.new_connection?4(sock, addr)
+tests.ZEO4.StorageServer.StorageServer.register_connection?4(storage_id, conn)
+tests.ZEO4.StorageServer.StorageServer.ruok?4()
+tests.ZEO4.StorageServer.StorageServer.server_status?4(storage_id)
+tests.ZEO4.StorageServer.StorageServer.start_thread?4(daemon=True)
+tests.ZEO4.StorageServer.StorageServer.stop_waiting?4(zeostore)
+tests.ZEO4.StorageServer.StorageServer.unlock_storage?4(zeostore)
+tests.ZEO4.StorageServer.StorageServer?1(addr, storages, read_only=0, invalidation_queue_size=100, invalidation_age=None, transaction_timeout=None, monitor_address=None, auth_protocol=None, auth_database=None, auth_realm=None, )
+tests.ZEO4.StorageServer.StorageServerDB.invalidate?4(tid, oids, version='')
+tests.ZEO4.StorageServer.StorageServerDB.invalidateCache?4()
+tests.ZEO4.StorageServer.StorageServerDB.transform_record_data?7
+tests.ZEO4.StorageServer.StorageServerDB?1(server, storage_id)
+tests.ZEO4.StorageServer.StubTimeoutThread.begin?4(client)
+tests.ZEO4.StorageServer.StubTimeoutThread.end?4(client)
+tests.ZEO4.StorageServer.StubTimeoutThread.is_alive?7
+tests.ZEO4.StorageServer.TimeoutThread.begin?4(client)
+tests.ZEO4.StorageServer.TimeoutThread.end?4(client)
+tests.ZEO4.StorageServer.TimeoutThread.run?4()
+tests.ZEO4.StorageServer.TimeoutThread?1(timeout)
+tests.ZEO4.StorageServer.ZEOStorage._check_tid?5(tid, exc=None)
+tests.ZEO4.StorageServer.ZEOStorage._checkread?5(oid, serial)
+tests.ZEO4.StorageServer.ZEOStorage._clear_transaction?5()
+tests.ZEO4.StorageServer.ZEOStorage._delete?5(oid, serial)
+tests.ZEO4.StorageServer.ZEOStorage._finish_auth?5(authenticated)
+tests.ZEO4.StorageServer.ZEOStorage._invalidate?5(tid)
+tests.ZEO4.StorageServer.ZEOStorage._marshal_error?5(error)
+tests.ZEO4.StorageServer.ZEOStorage._op_error?5(oid, err, op)
+tests.ZEO4.StorageServer.ZEOStorage._pack_impl?5(time)
+tests.ZEO4.StorageServer.ZEOStorage._restore?5(oid, serial, data, prev_txn)
+tests.ZEO4.StorageServer.ZEOStorage._store?5(oid, serial, data, blobfile=None)
+tests.ZEO4.StorageServer.ZEOStorage._try_to_vote?5(delay=None)
+tests.ZEO4.StorageServer.ZEOStorage._undo?5(trans_id)
+tests.ZEO4.StorageServer.ZEOStorage._unlock_callback?5(delay)
+tests.ZEO4.StorageServer.ZEOStorage.checkCurrentSerialInTransaction?4(oid, serial, id)
+tests.ZEO4.StorageServer.ZEOStorage.deleteObject?4(oid, serial, id)
+tests.ZEO4.StorageServer.ZEOStorage.endZeoVerify?4()
+tests.ZEO4.StorageServer.ZEOStorage.extensions?7
+tests.ZEO4.StorageServer.ZEOStorage.getAuthProtocol?4()
+tests.ZEO4.StorageServer.ZEOStorage.getExtensionMethods?4()
+tests.ZEO4.StorageServer.ZEOStorage.getInvalidations?4(tid)
+tests.ZEO4.StorageServer.ZEOStorage.get_info?4()
+tests.ZEO4.StorageServer.ZEOStorage.get_size_info?4()
+tests.ZEO4.StorageServer.ZEOStorage.history?4(tid, size=1)
+tests.ZEO4.StorageServer.ZEOStorage.iterator_gc?4(iids)
+tests.ZEO4.StorageServer.ZEOStorage.iterator_next?4(iid)
+tests.ZEO4.StorageServer.ZEOStorage.iterator_record_next?4(iid)
+tests.ZEO4.StorageServer.ZEOStorage.iterator_record_start?4(txn_iid, tid)
+tests.ZEO4.StorageServer.ZEOStorage.iterator_start?4(start, stop)
+tests.ZEO4.StorageServer.ZEOStorage.loadBefore?4(oid, tid)
+tests.ZEO4.StorageServer.ZEOStorage.loadEx?4(oid)
+tests.ZEO4.StorageServer.ZEOStorage.log?4(msg, level=logging.INFO, exc_info=False)
+tests.ZEO4.StorageServer.ZEOStorage.new_oids?4(n=100)
+tests.ZEO4.StorageServer.ZEOStorage.notifyConnected?4(conn)
+tests.ZEO4.StorageServer.ZEOStorage.notifyDisconnected?4()
+tests.ZEO4.StorageServer.ZEOStorage.pack?4(time, wait=1)
+tests.ZEO4.StorageServer.ZEOStorage.register?4(storage_id, read_only)
+tests.ZEO4.StorageServer.ZEOStorage.restorea?4(oid, serial, data, prev_txn, id)
+tests.ZEO4.StorageServer.ZEOStorage.sendBlob?4(oid, serial)
+tests.ZEO4.StorageServer.ZEOStorage.server_status?4()
+tests.ZEO4.StorageServer.ZEOStorage.set_client_label?4(label)
+tests.ZEO4.StorageServer.ZEOStorage.set_database?4(database)
+tests.ZEO4.StorageServer.ZEOStorage.setup_delegation?4()
+tests.ZEO4.StorageServer.ZEOStorage.storeBlobChunk?4(chunk)
+tests.ZEO4.StorageServer.ZEOStorage.storeBlobEnd?4(oid, serial, data, id)
+tests.ZEO4.StorageServer.ZEOStorage.storeBlobShared?4(oid, serial, data, filename, id)
+tests.ZEO4.StorageServer.ZEOStorage.storeBlobStart?4()
+tests.ZEO4.StorageServer.ZEOStorage.storea?4(oid, serial, data, id)
+tests.ZEO4.StorageServer.ZEOStorage.tpc_abort?4(tid)
+tests.ZEO4.StorageServer.ZEOStorage.tpc_begin?4(id, user, description, ext, tid=None, status=" ")
+tests.ZEO4.StorageServer.ZEOStorage.tpc_finish?4(id)
+tests.ZEO4.StorageServer.ZEOStorage.undo?4(**k)
+tests.ZEO4.StorageServer.ZEOStorage.undoInfo?4(first, last, spec)
+tests.ZEO4.StorageServer.ZEOStorage.undoLog?4(first, last)
+tests.ZEO4.StorageServer.ZEOStorage.undoa?4(trans_id, tid)
+tests.ZEO4.StorageServer.ZEOStorage.verify?4(oid, tid)
+tests.ZEO4.StorageServer.ZEOStorage.vote?4(tid)
+tests.ZEO4.StorageServer.ZEOStorage.zeoVerify?4(oid, s)
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.abortVersion?7
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.commitVersion?4(*a, **k)
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.getInfo?4()
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.getInvalidations?4(tid)
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.getSerial?4(oid)
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.history?4(oid, version, size=1)
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.loadEx?4(oid, version='')
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.modifiedInVersion?4(oid)
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.storeBlobEnd?4(oid, serial, data, version, id)
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.storeBlobShared?4(oid, serial, data, filename, version, id)
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.storea?4(oid, serial, data, version, id)
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.verify?4(oid, version, tid)
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.versionEmpty?4(version)
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.versions?4()
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.zeoLoad?4(oid)
+tests.ZEO4.StorageServer.ZEOStorage308Adapter.zeoVerify?4(oid, s, sv=None)
+tests.ZEO4.StorageServer.ZEOStorage308Adapter?1(storage)
+tests.ZEO4.StorageServer.ZEOStorage?1(server, read_only=0, auth_realm=None)
+tests.ZEO4.StorageServer._addr_label?5(addr)
+tests.ZEO4.StorageServer._level_for_waiting?5(waiting)
+tests.ZEO4.StorageServer.log?4(message, level=logging.INFO, label='', exc_info=False)
+tests.ZEO4.StorageServer.logger?7
+tests.ZEO4.StorageServer.run_in_thread?4(method, *args)
+tests.ZEO4.auth._auth_modules?8
+tests.ZEO4.auth.auth_digest.DigestClient.extensions?7
+tests.ZEO4.auth.auth_digest.DigestClient.start?4(username, realm, password)
+tests.ZEO4.auth.auth_digest.DigestDatabase._store_password?5(username, password)
+tests.ZEO4.auth.auth_digest.DigestDatabase?1(filename, realm=None)
+tests.ZEO4.auth.auth_digest.StorageClass._get_nonce?5()
+tests.ZEO4.auth.auth_digest.StorageClass._get_time?5()
+tests.ZEO4.auth.auth_digest.StorageClass.auth_get_challenge?4()
+tests.ZEO4.auth.auth_digest.StorageClass.auth_response?4(resp)
+tests.ZEO4.auth.auth_digest.StorageClass.extensions?7
+tests.ZEO4.auth.auth_digest.StorageClass.set_database?4(database)
+tests.ZEO4.auth.auth_digest.get_random_bytes?4(n=8)
+tests.ZEO4.auth.auth_digest.hexdigest?4(s)
+tests.ZEO4.auth.auth_digest.session_key?4(h_up, nonce)
+tests.ZEO4.auth.base.Client.extensions?7
+tests.ZEO4.auth.base.Client?1(stub)
+tests.ZEO4.auth.base.Database._store_password?5(username, password)
+tests.ZEO4.auth.base.Database.add_user?4(username, password)
+tests.ZEO4.auth.base.Database.change_password?4(username, password)
+tests.ZEO4.auth.base.Database.del_user?4(username)
+tests.ZEO4.auth.base.Database.get_password?4(username)
+tests.ZEO4.auth.base.Database.hash?4(s)
+tests.ZEO4.auth.base.Database.load?4()
+tests.ZEO4.auth.base.Database.realm?7
+tests.ZEO4.auth.base.Database.save?4(fd=None)
+tests.ZEO4.auth.base.Database?1(filename, realm=None)
+tests.ZEO4.auth.base.sort?4(L)
+tests.ZEO4.auth.get_module?4(name)
+tests.ZEO4.auth.hmac.HMAC.copy?4()
+tests.ZEO4.auth.hmac.HMAC.digest?4()
+tests.ZEO4.auth.hmac.HMAC.hexdigest?4()
+tests.ZEO4.auth.hmac.HMAC.update?4(msg)
+tests.ZEO4.auth.hmac.HMAC?1(key, msg = None, digestmod = None)
+tests.ZEO4.auth.hmac._strxor?5(s1, s2)
+tests.ZEO4.auth.hmac.digest_size?7
+tests.ZEO4.auth.hmac.new?4(key, msg = None, digestmod = None)
+tests.ZEO4.auth.register_module?4(name, storage_class, client, db)
+tests.ZEO4.monitor.StatsClient.close?4()
+tests.ZEO4.monitor.StatsClient.handle_write?4()
+tests.ZEO4.monitor.StatsClient.readable?4()
+tests.ZEO4.monitor.StatsClient.writable?4()
+tests.ZEO4.monitor.StatsClient.write?4(s)
+tests.ZEO4.monitor.StatsClient?1(sock, addr)
+tests.ZEO4.monitor.StatsServer.StatsConnectionClass?7
+tests.ZEO4.monitor.StatsServer.dump?4(f)
+tests.ZEO4.monitor.StatsServer.handle_accept?4()
+tests.ZEO4.monitor.StatsServer.readable?4()
+tests.ZEO4.monitor.StatsServer.writable?4()
+tests.ZEO4.monitor.StatsServer?1(addr, stats)
+tests.ZEO4.monitor.StorageStats.clients?4()
+tests.ZEO4.monitor.StorageStats.dump?4(f)
+tests.ZEO4.monitor.StorageStats.parse?4(s)
+tests.ZEO4.monitor.StorageStats?1(connections=None)
+tests.ZEO4.monitor.zeo_version?7
+tests.ZEO4.runzeo.FSConfig.getSectionName?4()
+tests.ZEO4.runzeo.FSConfig?1(name, path)
+tests.ZEO4.runzeo.ZEOOptions.logsectionname?7
+tests.ZEO4.runzeo.ZEOOptions.realize?4(*a, **k)
+tests.ZEO4.runzeo.ZEOOptions.schemadir?7
+tests.ZEO4.runzeo.ZEOOptions?1()
+tests.ZEO4.runzeo.ZEOOptionsMixin.add_zeo_options?4()
+tests.ZEO4.runzeo.ZEOOptionsMixin.handle_address?4(arg)
+tests.ZEO4.runzeo.ZEOOptionsMixin.handle_filename?4(arg)
+tests.ZEO4.runzeo.ZEOOptionsMixin.handle_monitor_address?4(arg)
+tests.ZEO4.runzeo.ZEOOptionsMixin.handle_test?4(*args)
+tests.ZEO4.runzeo.ZEOOptionsMixin.storages?7
+tests.ZEO4.runzeo.ZEOOptionsMixin.testing_exit_immediately?7
+tests.ZEO4.runzeo.ZEOServer._get_pidfile?5()
+tests.ZEO4.runzeo.ZEOServer.can_connect?4(family, address)
+tests.ZEO4.runzeo.ZEOServer.check_socket?4()
+tests.ZEO4.runzeo.ZEOServer.clear_socket?4()
+tests.ZEO4.runzeo.ZEOServer.create_server?4()
+tests.ZEO4.runzeo.ZEOServer.handle_sighup?4()
+tests.ZEO4.runzeo.ZEOServer.handle_sigint?4()
+tests.ZEO4.runzeo.ZEOServer.handle_sigterm?4()
+tests.ZEO4.runzeo.ZEOServer.handle_sigusr2?4()
+tests.ZEO4.runzeo.ZEOServer.loop_forever?4()
+tests.ZEO4.runzeo.ZEOServer.main?4()
+tests.ZEO4.runzeo.ZEOServer.make_pidfile?4()
+tests.ZEO4.runzeo.ZEOServer.open_storages?4()
+tests.ZEO4.runzeo.ZEOServer.remove_pidfile?4()
+tests.ZEO4.runzeo.ZEOServer.setup_default_logging?4()
+tests.ZEO4.runzeo.ZEOServer.setup_signals?4()
+tests.ZEO4.runzeo.ZEOServer.setup_win32_signals?4()
+tests.ZEO4.runzeo.ZEOServer.wrapper?4(frame_dummy, method=method)
+tests.ZEO4.runzeo.ZEOServer?1(options)
+tests.ZEO4.runzeo._pid?8
+tests.ZEO4.runzeo.create_server?4(storages, options)
+tests.ZEO4.runzeo.init_signames?4()
+tests.ZEO4.runzeo.log?4(msg, level=logging.INFO, exc_info=False)
+tests.ZEO4.runzeo.logger?7
+tests.ZEO4.runzeo.main?4(args=None)
+tests.ZEO4.runzeo.parse_binding_address?4(arg)
+tests.ZEO4.runzeo.signame?4(sig)
+tests.ZEO4.runzeo.signames?7
+tests.ZEO4.runzeo.windows_shutdown_handler?4()
+tests.ZEO4.zrpc._hmac.HMAC.copy?4()
+tests.ZEO4.zrpc._hmac.HMAC.digest?4()
+tests.ZEO4.zrpc._hmac.HMAC.hexdigest?4()
+tests.ZEO4.zrpc._hmac.HMAC.update?4(msg)
+tests.ZEO4.zrpc._hmac.HMAC?1(key, msg = None, digestmod = None)
+tests.ZEO4.zrpc._hmac._strxor?5(s1, s2)
+tests.ZEO4.zrpc._hmac.digest_size?7
+tests.ZEO4.zrpc._hmac.new?4(key, msg = None, digestmod = None)
+tests.ZEO4.zrpc.client.ConnectThread._connect_wrappers?5(wrappers, deadline)
+tests.ZEO4.zrpc.client.ConnectThread._create_wrappers?5()
+tests.ZEO4.zrpc.client.ConnectThread._expand_addrlist?5()
+tests.ZEO4.zrpc.client.ConnectThread._fallback_wrappers?5(wrappers, deadline)
+tests.ZEO4.zrpc.client.ConnectThread.run?4()
+tests.ZEO4.zrpc.client.ConnectThread.stop?4()
+tests.ZEO4.zrpc.client.ConnectThread.try_connecting?4(timeout)
+tests.ZEO4.zrpc.client.ConnectThread?1(mgr, client)
+tests.ZEO4.zrpc.client.ConnectWrapper.close?4()
+tests.ZEO4.zrpc.client.ConnectWrapper.connect_procedure?4()
+tests.ZEO4.zrpc.client.ConnectWrapper.fileno?4()
+tests.ZEO4.zrpc.client.ConnectWrapper.notify_client?4()
+tests.ZEO4.zrpc.client.ConnectWrapper.test_connection?4()
+tests.ZEO4.zrpc.client.ConnectWrapper?1(domain, addr, mgr, client)
+tests.ZEO4.zrpc.client.ConnectionManager._CONNECT_IN_PROGRESS?8
+tests.ZEO4.zrpc.client.ConnectionManager._CONNECT_OK?8
+tests.ZEO4.zrpc.client.ConnectionManager._guess_type?5(addr)
+tests.ZEO4.zrpc.client.ConnectionManager._parse_addrs?5(addrs)
+tests.ZEO4.zrpc.client.ConnectionManager._start_asyncore_loop?5()
+tests.ZEO4.zrpc.client.ConnectionManager.attempt_connect?4()
+tests.ZEO4.zrpc.client.ConnectionManager.close?4()
+tests.ZEO4.zrpc.client.ConnectionManager.close_conn?4(conn)
+tests.ZEO4.zrpc.client.ConnectionManager.connect?4(sync=0)
+tests.ZEO4.zrpc.client.ConnectionManager.connect_done?4(conn, preferred)
+tests.ZEO4.zrpc.client.ConnectionManager.is_connected?4()
+tests.ZEO4.zrpc.client.ConnectionManager.new_addrs?4(addrs)
+tests.ZEO4.zrpc.client.ConnectionManager.sync_wait?7
+tests.ZEO4.zrpc.client.ConnectionManager?1(addrs, client, tmin=1, tmax=180)
+tests.ZEO4.zrpc.client.client_loop?4(map)
+tests.ZEO4.zrpc.client.client_timeout?4()
+tests.ZEO4.zrpc.connection.Connection.callAsync?4(method, *args)
+tests.ZEO4.zrpc.connection.Connection.callAsyncIterator?4(iterator)
+tests.ZEO4.zrpc.connection.Connection.callAsyncNoPoll?4(method, *args)
+tests.ZEO4.zrpc.connection.Connection.callAsyncNoSend?4(method, *args)
+tests.ZEO4.zrpc.connection.Connection.clients_we_can_talk_to?7
+tests.ZEO4.zrpc.connection.Connection.close?4()
+tests.ZEO4.zrpc.connection.Connection.current_protocol?7
+tests.ZEO4.zrpc.connection.Connection.handle_error?4()
+tests.ZEO4.zrpc.connection.Connection.handle_reply?4(msgid, ret)
+tests.ZEO4.zrpc.connection.Connection.handle_request?4(msgid, async_, name, args)
+tests.ZEO4.zrpc.connection.Connection.handshake?4()
+tests.ZEO4.zrpc.connection.Connection.log?4(message, level=BLATHER, exc_info=False)
+tests.ZEO4.zrpc.connection.Connection.message_input?4(message)
+tests.ZEO4.zrpc.connection.Connection.poll?4()
+tests.ZEO4.zrpc.connection.Connection.recv_handshake?4(proto)
+tests.ZEO4.zrpc.connection.Connection.register_object?4(obj)
+tests.ZEO4.zrpc.connection.Connection.return_error?4(msgid, err_type, err_value)
+tests.ZEO4.zrpc.connection.Connection.send_call?4(method, args, async_=False)
+tests.ZEO4.zrpc.connection.Connection.servers_we_can_talk_to?7
+tests.ZEO4.zrpc.connection.Connection.setSessionKey?4(key)
+tests.ZEO4.zrpc.connection.Connection.unlogged_exception_types?7
+tests.ZEO4.zrpc.connection.Connection?1(sock, addr, obj, tag, map=None)
+tests.ZEO4.zrpc.connection.Delay.error?4(exc_info)
+tests.ZEO4.zrpc.connection.Delay.msgid?7
+tests.ZEO4.zrpc.connection.Delay.reply?4(obj)
+tests.ZEO4.zrpc.connection.Delay.set_sender?4(msgid, conn)
+tests.ZEO4.zrpc.connection.MTDelay.error?4(exc_info)
+tests.ZEO4.zrpc.connection.MTDelay.reply?4(obj)
+tests.ZEO4.zrpc.connection.MTDelay.set_sender?4(*args)
+tests.ZEO4.zrpc.connection.MTDelay?1()
+tests.ZEO4.zrpc.connection.ManagedClientConnection._deferred_call?5(method, *args)
+tests.ZEO4.zrpc.connection.ManagedClientConnection._deferred_wait?5(msgid)
+tests.ZEO4.zrpc.connection.ManagedClientConnection._new_msgid?5()
+tests.ZEO4.zrpc.connection.ManagedClientConnection.base_message_output?7
+tests.ZEO4.zrpc.connection.ManagedClientConnection.call?4(method, *args)
+tests.ZEO4.zrpc.connection.ManagedClientConnection.close?4()
+tests.ZEO4.zrpc.connection.ManagedClientConnection.handle_reply?4(msgid, args)
+tests.ZEO4.zrpc.connection.ManagedClientConnection.handshake?4()
+tests.ZEO4.zrpc.connection.ManagedClientConnection.message_output?4(message)
+tests.ZEO4.zrpc.connection.ManagedClientConnection.recv_handshake?4(proto)
+tests.ZEO4.zrpc.connection.ManagedClientConnection.send_reply?4(msgid, ret)
+tests.ZEO4.zrpc.connection.ManagedClientConnection.wait?4(msgid)
+tests.ZEO4.zrpc.connection.ManagedClientConnection?1(sock, addr, mgr)
+tests.ZEO4.zrpc.connection.ManagedServerConnection.close?4()
+tests.ZEO4.zrpc.connection.ManagedServerConnection.handshake?4()
+tests.ZEO4.zrpc.connection.ManagedServerConnection.poll?7
+tests.ZEO4.zrpc.connection.ManagedServerConnection.recv_handshake?4(proto)
+tests.ZEO4.zrpc.connection.ManagedServerConnection.send_reply?4(msgid, ret, immediately=True)
+tests.ZEO4.zrpc.connection.ManagedServerConnection.unlogged_exception_types?7
+tests.ZEO4.zrpc.connection.ManagedServerConnection?1(sock, addr, obj, mgr)
+tests.ZEO4.zrpc.connection.REPLY?7
+tests.ZEO4.zrpc.connection.Result.set_sender?4(msgid, conn)
+tests.ZEO4.zrpc.connection.Result?1(*args)
+tests.ZEO4.zrpc.connection.debug_zrpc?7
+tests.ZEO4.zrpc.connection.exception_type_type?7
+tests.ZEO4.zrpc.connection.server_loop?4(map)
+tests.ZEO4.zrpc.log.LOG_THREAD_ID?7
+tests.ZEO4.zrpc.log.REPR_LIMIT?7
+tests.ZEO4.zrpc.log._label?8
+tests.ZEO4.zrpc.log.log?4(message, level=BLATHER, label=None, exc_info=False)
+tests.ZEO4.zrpc.log.logger?7
+tests.ZEO4.zrpc.log.new_label?4()
+tests.ZEO4.zrpc.log.short_repr?4(obj)
+tests.ZEO4.zrpc.server.Dispatcher._open_socket?5()
+tests.ZEO4.zrpc.server.Dispatcher.handle_accept?4()
+tests.ZEO4.zrpc.server.Dispatcher.readable?4()
+tests.ZEO4.zrpc.server.Dispatcher.writable?4()
+tests.ZEO4.zrpc.server.Dispatcher?1(addr, factory=Connection, map=None)
+tests.ZEO4.zrpc.server.loop?7
+tests.ZEO4.zrpc.smac.MAC_BIT?7
+tests.ZEO4.zrpc.smac.SEND_SIZE?7
+tests.ZEO4.zrpc.smac.SizedMessageAsyncConnection.close?4()
+tests.ZEO4.zrpc.smac.SizedMessageAsyncConnection.get_addr?4()
+tests.ZEO4.zrpc.smac.SizedMessageAsyncConnection.hack?4()
+tests.ZEO4.zrpc.smac.SizedMessageAsyncConnection.handle_close?4()
+tests.ZEO4.zrpc.smac.SizedMessageAsyncConnection.handle_read?4()
+tests.ZEO4.zrpc.smac.SizedMessageAsyncConnection.handle_write?4()
+tests.ZEO4.zrpc.smac.SizedMessageAsyncConnection.message_output?4(message)
+tests.ZEO4.zrpc.smac.SizedMessageAsyncConnection.readable?4()
+tests.ZEO4.zrpc.smac.SizedMessageAsyncConnection.setSessionKey?4(sesskey)
+tests.ZEO4.zrpc.smac.SizedMessageAsyncConnection.should_close?4()
+tests.ZEO4.zrpc.smac.SizedMessageAsyncConnection.socket?7
+tests.ZEO4.zrpc.smac.SizedMessageAsyncConnection.writable?4()
+tests.ZEO4.zrpc.smac.SizedMessageAsyncConnection?1(sock, addr, map=None)
+tests.ZEO4.zrpc.smac._close_marker?8
+tests.ZEO4.zrpc.smac.expected_socket_read_errors?7
+tests.ZEO4.zrpc.smac.expected_socket_write_errors?7
+tests.ZEO4.zrpc.smac.tmp_dict?7
+tests.ZEO4.zrpc.trigger._triggerbase._close?5()
+tests.ZEO4.zrpc.trigger._triggerbase._physical_pull?5()
+tests.ZEO4.zrpc.trigger._triggerbase.close?4()
+tests.ZEO4.zrpc.trigger._triggerbase.handle_close?4()
+tests.ZEO4.zrpc.trigger._triggerbase.handle_connect?4()
+tests.ZEO4.zrpc.trigger._triggerbase.handle_read?4()
+tests.ZEO4.zrpc.trigger._triggerbase.kind?7
+tests.ZEO4.zrpc.trigger._triggerbase.pull_trigger?4(*thunk)
+tests.ZEO4.zrpc.trigger._triggerbase.readable?4()
+tests.ZEO4.zrpc.trigger._triggerbase.writable?4()
+tests.ZEO4.zrpc.trigger._triggerbase?2()
+tests.ZEO4.zrpc.trigger.trigger._close?5()
+tests.ZEO4.zrpc.trigger.trigger._physical_pull?5()
+tests.ZEO4.zrpc.trigger.trigger.kind?7
+tests.ZEO4.zrpc.trigger.trigger?1(map=None)
+tests.ZEO4.zrpc.trigger.trigger_1._close?5()
+tests.ZEO4.zrpc.trigger.trigger_1._physical_pull?5()
+tests.ZEO4.zrpc.trigger.trigger_1.kind?7
+tests.forker.DEBUG?7
+tests.forker.ThreadlessQueue?7
+tests.forker.ZEO4_SERVER?7
+tests.forker.ZEOConfig?7
+tests.forker._quote_arg?5(s)
+tests.forker.can_connect?4(port)
+tests.forker.cleanup_servers?4()
+tests.forker.debug_logging?7
+tests.forker.encode_format?4(fmt)
+tests.forker.get_port?4(ignored=None)
+tests.forker.logger?7
+tests.forker.runner?7
+tests.forker.setUp?4(test)
+tests.forker.shutdown_zeo_server?7
+tests.forker.skip_if_testing_client_against_zeo4?7
+tests.forker.start_server?4(storage_conf=None, zeo_conf=None, port=None, keep=False, addr=None, path='Data.fs', protocol=None, blob_dir=None, suicide=True, debug=False, **kw)
+tests.forker.start_zeo_server?7
+tests.forker.stop_runner?7
+tests.forker.stop_server?4(stop)
+tests.forker.wait_connected?4(storage)
+tests.forker.wait_decorator?4(f)
+tests.forker.wait_disconnected?4(storage)
+tests.forker.wait_until?4(label=None, func=None, timeout=30, onfail=None)
+tests.forker.whine?7
+tests.servertesting.StorageServer?1(addr='test_addr', storages=None, **kw)
+tests.servertesting.client?4(server, name='client')
+tests.speed.ZEOExit.delete_fs?4()
+tests.speed.ZEOExit.handle_close?4()
+tests.speed.ZEOExit.handle_read?4()
+tests.speed.ZEOExit.readable?4()
+tests.speed.ZEOExit.writable?4()
+tests.speed.fs_name?7
+tests.speed.main?4(args)
+tests.speed.mean?4(l)
+tests.speed.usage?7
+tests.speed.work?4(db, results, nrep, compress, data, detailed, minimize, threadno=None)
+tests.stress.MAX_DEPTH?7
+tests.stress.MAX_OBJSIZE?7
+tests.stress.MIN_OBJSIZE?7
+tests.stress.NUM_CONNECTIONS?7
+tests.stress.NUM_ROOTS?7
+tests.stress.NUM_TRANSACTIONS_PER_CONN?7
+tests.stress._start_child?5(zaddr)
+tests.stress.an_object?4()
+tests.stress.exitserver?4()
+tests.stress.main?4()
+tests.stress.setup?4(cn)
+tests.stress.start_child?4(zaddr)
+tests.stress.work?4(cn)
+tests.testConfig.ZEOConfigTest.test_blob_cache_size_check?4()
+tests.testConfig.ZEOConfigTest.test_client_variations?4()
+tests.testConfig.ZEOConfigTest.test_default_zeo_config?4(**client_settings)
+tests.testConfig.ZEOConfigTestBase._client_assertions?5(client, addr, connected=True, cache_size=20 * (1<<20), cache_path=None, blob_dir=None, shared_blob_dir=False, blob_cache_size=None, blob_cache_size_check=10, read_only=False, read_only_fallback=False, server_sync=False, wait_timeout=30, client_label=None, storage='1', name=None, )
+tests.testConfig.ZEOConfigTestBase.setUp?7
+tests.testConfig.ZEOConfigTestBase.start_client?4(addr, settings='', **kw)
+tests.testConfig.ZEOConfigTestBase.start_server?4(settings='', **kw)
+tests.testConfig.test_suite?4()
+tests.testConnection.FileStorageConfig.getConfig?4(path, create, read_only)
+tests.testConnection.MappingStorageConfig.getConfig?4(path, create, read_only)
+tests.testConnection.invalidations_while_connecting?4()
+tests.testConnection.test_classes?7
+tests.testConnection.test_suite?4()
+tests.testConversionSupport.FakeConnection.addr?7
+tests.testConversionSupport.FakeConnection.async_?7
+tests.testConversionSupport.FakeConnection.call_soon_threadsafe?7
+tests.testConversionSupport.FakeConnection.protocol_version?7
+tests.testConversionSupport.FakeServer.client_conflict_resolution?7
+tests.testConversionSupport.FakeServer.lock_managers?7
+tests.testConversionSupport.FakeServer.register_connection?4()
+tests.testConversionSupport.FakeServer.storages?7
+tests.testConversionSupport.FakeStorage.record_iternext?4(next=None)
+tests.testConversionSupport.FakeStorageBase.isReadOnly?4()
+tests.testConversionSupport.test_client_record_iternext?4()
+tests.testConversionSupport.test_server_record_iternext?4()
+tests.testConversionSupport.test_suite?4()
+tests.testTransactionBuffer.TransBufTests.checkOrderPreserved?4()
+tests.testTransactionBuffer.TransBufTests.checkTypicalUsage?4()
+tests.testTransactionBuffer.new_store_data?4()
+tests.testTransactionBuffer.random_string?4(size)
+tests.testTransactionBuffer.store?4(tbuf, resolved=False)
+tests.testTransactionBuffer.test_suite?4()
+tests.testZEO.BlobAdaptedFileStorageTests.checkStoreAndLoadBlob?4()
+tests.testZEO.BlobAdaptedFileStorageTests.check_data?4()
+tests.testZEO.BlobWritableCacheTests.blob_cache_dir?7
+tests.testZEO.BlobWritableCacheTests.shared_blob_dir?7
+tests.testZEO.ClientConflictResolutionTests.getConfig?4()
+tests.testZEO.ClientConflictResolutionTests.getZEOConfig?4()
+tests.testZEO.ClientDisconnected_errors_are_TransientErrors?4()
+tests.testZEO.CommonBlobTests.blob_cache_dir?7
+tests.testZEO.CommonBlobTests.blobdir?7
+tests.testZEO.CommonBlobTests.checkLoadBlob?4()
+tests.testZEO.CommonBlobTests.checkStoreBlob?4()
+tests.testZEO.CommonBlobTests.checkStoreBlob_wrong_partition?4()
+tests.testZEO.CommonBlobTests.checkTemporaryDirectory?4()
+tests.testZEO.CommonBlobTests.checkTransactionBufferCleanup?4()
+tests.testZEO.CommonBlobTests.fail?4()
+tests.testZEO.CommonBlobTests.getConfig?4()
+tests.testZEO.DemoStorageTests.checkPackAllRevisions?7
+tests.testZEO.DemoStorageTests.checkPackWithMultiDatabaseReferences?4()
+tests.testZEO.DemoStorageTests.checkUndoZombie?4()
+tests.testZEO.DemoStorageTests.getConfig?4()
+tests.testZEO.DummyDB.invalidate?4(*args)
+tests.testZEO.DummyDB.invalidateCache?4()
+tests.testZEO.DummyDB.transform_record_data?7
+tests.testZEO.DummyDB_1._invalidatedCache?8
+tests.testZEO.DummyDB_1.invalidate?4(**k)
+tests.testZEO.DummyDB_1.invalidateCache?4()
+tests.testZEO.DummyDB_1.transform_record_data?7
+tests.testZEO.FauxConn.addr?7
+tests.testZEO.FauxConn.async_?4(method, *args)
+tests.testZEO.FauxConn.call_soon_threadsafe?7
+tests.testZEO.FauxConn.peer_protocol_version?7
+tests.testZEO.FauxConn.protocol_version?7
+tests.testZEO.FauxConn.serials?7
+tests.testZEO.FileStorageClientHexTests._wrap_client?5(client)
+tests.testZEO.FileStorageClientHexTests.getConfig?4()
+tests.testZEO.FileStorageClientHexTests.use_extension_bytes?7
+tests.testZEO.FileStorageHexTests._expected_interfaces?8
+tests.testZEO.FileStorageHexTests.getConfig?4()
+tests.testZEO.FileStorageRecoveryTests._new_storage?5()
+tests.testZEO.FileStorageRecoveryTests.getConfig?4()
+tests.testZEO.FileStorageRecoveryTests.new_dest?4()
+tests.testZEO.FileStorageRecoveryTests.setUp?4()
+tests.testZEO.FileStorageRecoveryTests.tearDown?4()
+tests.testZEO.FileStorageSSLTests._client_options?5()
+tests.testZEO.FileStorageSSLTests.getZEOConfig?4()
+tests.testZEO.FileStorageTests._expected_interfaces?8
+tests.testZEO.FileStorageTests.checkInterfaceFromRemoteStorage?4()
+tests.testZEO.FileStorageTests.getConfig?4()
+tests.testZEO.FullGenericTests.checkPackUndoLog?4()
+tests.testZEO.GenericTestBase._client_options?5()
+tests.testZEO.GenericTestBase._do_store_in_separate_thread?5(oid, revid, voted)
+tests.testZEO.GenericTestBase._wrap_client?5(client)
+tests.testZEO.GenericTestBase.blob_cache_dir?7
+tests.testZEO.GenericTestBase.checkSortKey?4()
+tests.testZEO.GenericTestBase.checkWriteMethods?4()
+tests.testZEO.GenericTestBase.do_store?4()
+tests.testZEO.GenericTestBase.getZEOConfig?4()
+tests.testZEO.GenericTestBase.open?4(read_only=0)
+tests.testZEO.GenericTestBase.server_debug?7
+tests.testZEO.GenericTestBase.setUp?4()
+tests.testZEO.GenericTestBase.shared_blob_dir?7
+tests.testZEO.GenericTestBase.tearDown?4()
+tests.testZEO.MappingStorageTests.checkSimpleIteration?4()
+tests.testZEO.MappingStorageTests.checkUndoZombie?4()
+tests.testZEO.MappingStorageTests.getConfig?4()
+tests.testZEO.MiscZEOTests.checkCreativeGetState?4()
+tests.testZEO.MiscZEOTests.checkLargeUpdate?4()
+tests.testZEO.MiscZEOTests.checkVolatileCacheWithImmediateLastTransaction?4()
+tests.testZEO.MiscZEOTests.checkZEOInvalidation?4()
+tests.testZEO.MultiprocessingTests.layer?7
+tests.testZEO.MultiprocessingTests.test_work_with_multiprocessing?4()
+tests.testZEO.ServerManagingClientStorage.close?4()
+tests.testZEO.ServerManagingClientStorage?1(name, blob_dir, shared=False, extrafsoptions='')
+tests.testZEO.ServerManagingClientStorageForIExternalGCTest.pack?4(t=None, referencesf=None)
+tests.testZEO.StorageServerWrapper.new_oid?4()
+tests.testZEO.StorageServerWrapper.registerDB?4(*args)
+tests.testZEO.StorageServerWrapper.send_reply?4(_, result)
+tests.testZEO.StorageServerWrapper.sortKey?4()
+tests.testZEO.StorageServerWrapper.store?4(oid, serial, data, version_ignored, transaction)
+tests.testZEO.StorageServerWrapper.supportsUndo?4()
+tests.testZEO.StorageServerWrapper.tpc_abort?4(transaction)
+tests.testZEO.StorageServerWrapper.tpc_begin?4(transaction)
+tests.testZEO.StorageServerWrapper.tpc_finish?4(transaction, func = lambda: None)
+tests.testZEO.StorageServerWrapper.tpc_vote?4(transaction)
+tests.testZEO.StorageServerWrapper?1(server, storage_id)
+tests.testZEO.Test_convenience_functions.test_ZEO_DB_convenience_error?4()
+tests.testZEO.Test_convenience_functions.test_ZEO_DB_convenience_ok?4()
+tests.testZEO.Test_convenience_functions.test_ZEO_client_convenience?4()
+tests.testZEO.Test_convenience_functions.test_ZEO_connection_convenience_ok?4()
+tests.testZEO.Test_convenience_functions.test_ZEO_connection_convenience_value?4()
+tests.testZEO.ZRPCConnectionTests.checkCatastrophicClientLoopFailure?4()
+tests.testZEO.ZRPCConnectionTests.checkConnectionInvalidationOnReconnect?4()
+tests.testZEO.ZRPCConnectionTests.checkExceptionLogsAtError?4()
+tests.testZEO.ZRPCConnectionTests.getConfig?4(path, create, read_only)
+tests.testZEO.can_use_empty_string_for_local_host_on_client?4()
+tests.testZEO.client_asyncore_thread_has_name?4()
+tests.testZEO.client_has_newer_data_than_server?4()
+tests.testZEO.client_labels?4()
+tests.testZEO.close_client_storage_w_invalidations?4()
+tests.testZEO.convenient_to_pass_port_to_client_and_ZEO_dot_client?4()
+tests.testZEO.create_storage_shared?4(name, blob_dir)
+tests.testZEO.dont_log_poskeyerrors_on_server?4()
+tests.testZEO.generate_script?4(name, src)
+tests.testZEO.getInvalidationsAfterServerRestart?4()
+tests.testZEO.gracefully_handle_abort_while_storing_many_blobs?4()
+tests.testZEO.history_over_zeo?4()
+tests.testZEO.invalidate_client_cache_entry_on_server_commit_error?4()
+tests.testZEO.logger?7
+tests.testZEO.multiple_storages_invalidation_queue_is_not_insane?4()
+tests.testZEO.open_convenience?4()
+tests.testZEO.quick_close_doesnt_kill_server?4()
+tests.testZEO.quick_test_classes?7
+tests.testZEO.read?4(filename)
+tests.testZEO.runzeo_logrotate_on_sigusr2?4()
+tests.testZEO.runzeo_without_configfile?4()
+tests.testZEO.script_template?7
+tests.testZEO.slow_test_classes?7
+tests.testZEO.test_prefetch?4(self)
+tests.testZEO.test_runzeo_msgpack_support?4()
+tests.testZEO.test_ruok?4()
+tests.testZEO.test_server_status?4()
+tests.testZEO.test_suite?4()
+tests.testZEO.tpc_finish_error?4()
+tests.testZEO.unix_domain_sockets?4()
+tests.testZEO.work_with_multiprocessing_process?4(name, addr, q)
+tests.testZEO2.errors_in_vote_should_clear_lock?4()
+tests.testZEO2.lock_sanity_check?4()
+tests.testZEO2.proper_handling_of_blob_conflicts?4()
+tests.testZEO2.proper_handling_of_errors_in_restart?4()
+tests.testZEO2.some_basic_locking_tests?4()
+tests.testZEO2.test_suite?4()
+tests.testZEOOptions.DEFAULT_BINDING_HOST?7
+tests.testZEOOptions.TestZEOOptions.OptionsClass?7
+tests.testZEOOptions.TestZEOOptions.configdata?7
+tests.testZEOOptions.TestZEOOptions.input_args?7
+tests.testZEOOptions.TestZEOOptions.output_args?7
+tests.testZEOOptions.TestZEOOptions.output_opts?7
+tests.testZEOOptions.TestZEOOptions.setUp?4()
+tests.testZEOOptions.TestZEOOptions.tearDown?4()
+tests.testZEOOptions.TestZEOOptions.test_commandline_overrides?4()
+tests.testZEOOptions.TestZEOOptions.test_configure?4()
+tests.testZEOOptions.TestZEOOptions.test_default_help?4()
+tests.testZEOOptions.TestZEOOptions.test_defaults_with_schema?4()
+tests.testZEOOptions.TestZEOOptions.test_defaults_without_schema?4()
+tests.testZEOOptions.test_suite?4()
+tests.testZEOServer.AttributeErrorTests.testFailCreateServer?4()
+tests.testZEOServer.CloseServerTests.testCallSequence?4()
+tests.testZEOServer.CloseServerTests.testFailCreateServer?4()
+tests.testZEOServer.CloseServerTests.testFailLoopForever?4()
+tests.testZEOServer.Options.address?7
+tests.testZEOServer.Options_1.address?7
+tests.testZEOServer.Options_2.address?7
+tests.testZEOServer.Options_2.assertion?7
+tests.testZEOServer.Options_3.address?7
+tests.testZEOServer.TestStorageServer.close?4()
+tests.testZEOServer.TestStorageServer?1(fail_create_server)
+tests.testZEOServer.TestZEOServer.check_socket?4()
+tests.testZEOServer.TestZEOServer.clear_socket?4()
+tests.testZEOServer.TestZEOServer.close_server?4()
+tests.testZEOServer.TestZEOServer.create_server?4()
+tests.testZEOServer.TestZEOServer.loop_forever?4()
+tests.testZEOServer.TestZEOServer.make_pidfile?4()
+tests.testZEOServer.TestZEOServer.open_storages?4()
+tests.testZEOServer.TestZEOServer.remove_pidfile?4()
+tests.testZEOServer.TestZEOServer.setup_default_logging?4()
+tests.testZEOServer.TestZEOServer.setup_signals?4()
+tests.testZEOServer.TestZEOServer?1(fail_create_server=False, fail_loop_forever=False)
+tests.testZEOServer.TestZEOServerSocket._not_unlinked?5(unlink, options)
+tests.testZEOServer.TestZEOServerSocket._unlinked?5(unlink, options)
+tests.testZEOServer.TestZEOServerSocket.test_clear_with_bytes?4(unlink)
+tests.testZEOServer.TestZEOServerSocket.test_clear_with_native_str?4(unlink)
+tests.testZEOServer.TestZEOServerSocket.test_clear_with_tuple?4(unlink)
+tests.testZEOServer.TestZEOServerSocket.test_clear_with_unicode_str?4(unlink)
+tests.test_cache.CacheTests.setUp?4()
+tests.test_cache.CacheTests.tearDown?4()
+tests.test_cache.CacheTests.testChangingCacheSize?4()
+tests.test_cache.CacheTests.testConversionOfLargeFreeBlocks?4()
+tests.test_cache.CacheTests.testCurrentObjectLargerThanCache?4()
+tests.test_cache.CacheTests.testEviction?4()
+tests.test_cache.CacheTests.testException?4()
+tests.test_cache.CacheTests.testInvalidate?4()
+tests.test_cache.CacheTests.testLastTid?4()
+tests.test_cache.CacheTests.testLoad?4()
+tests.test_cache.CacheTests.testNonCurrent?4()
+tests.test_cache.CacheTests.testOldObjectLargerThanCache?4()
+tests.test_cache.CacheTests.testSerialization?4()
+tests.test_cache.CacheTests.testSetAnyLastTidOnEmptyCache?4()
+tests.test_cache.CacheTests.testVeryLargeCaches?4()
+tests.test_cache.CacheTests.test_clear_zeo_cache?4()
+tests.test_cache.CacheTests.test_loadBefore_doesnt_miss_current?4()
+tests.test_cache.broken_non_current?4()
+tests.test_cache.cache_simul_properly_handles_load_miss_after_eviction_and_inval?4()
+tests.test_cache.cache_trace_analysis?4()
+tests.test_cache.cannot_open_same_cache_file_twice?4()
+tests.test_cache.full_cache_is_valid?4()
+tests.test_cache.hexprint?4(file)
+tests.test_cache.invalidations_with_current_tid_dont_wreck_cache?4()
+tests.test_cache.kill_does_not_cause_cache_corruption?4()
+tests.test_cache.n1?7
+tests.test_cache.n2?7
+tests.test_cache.n3?7
+tests.test_cache.n4?7
+tests.test_cache.n5?7
+tests.test_cache.oid?4(o)
+tests.test_cache.rename_bad_cache_file?4()
+tests.test_cache.test_suite?4()
+tests.test_cache.tid?7
+tests.test_client_credentials.ClientAuthTests.register?4(storage_id, read_only, credentials=self)
+tests.test_client_credentials.ClientAuthTests.setUp?4()
+tests.test_client_credentials.ClientAuthTests.tearDown?4()
+tests.test_client_credentials.ClientAuthTests.test_passing_credentials?4()
+tests.test_client_credentials.test_suite?4()
+tests.test_client_side_conflict_resolution.ClientSideConflictResolutionTests.test_client_side?4()
+tests.test_client_side_conflict_resolution.ClientSideConflictResolutionTests.test_server_side?4()
+tests.test_client_side_conflict_resolution.test_suite?4()
+tests.test_marshal.MarshalTests.testServerDecodeZopeUndoFilter?4()
+tests.test_marshal.test_suite?4()
+tests.test_sync.SyncTests.instrument?4()
+tests.test_sync.SyncTests.ping?4()
+tests.test_sync.SyncTests.test_server_sync?4()
+tests.testssl.SSLConfigTest.test_ssl_basic?4()
+tests.testssl.SSLConfigTest.test_ssl_hostname_check?4()
+tests.testssl.SSLConfigTest.test_ssl_pw?4()
+tests.testssl.SSLConfigTestMockiavellian.assert_context?4(factory, context, cert=(server_cert, server_key, None), verify_mode=ssl.CERT_REQUIRED, check_hostname=False, cafile=None, capath=None, )
+tests.testssl.SSLConfigTestMockiavellian.test_ssl_mockiavellian_client_auth_dir?4(ClientStorage, factory, *_)
+tests.testssl.SSLConfigTestMockiavellian.test_ssl_mockiavellian_client_auth_file?4(ClientStorage, factory, *_)
+tests.testssl.SSLConfigTestMockiavellian.test_ssl_mockiavellian_client_check_hostname?4(ClientStorage, factory, *_)
+tests.testssl.SSLConfigTestMockiavellian.test_ssl_mockiavellian_client_no_ssl?4(ClientStorage, factory, *_)
+tests.testssl.SSLConfigTestMockiavellian.test_ssl_mockiavellian_client_pw?4(ClientStorage, factory, *_)
+tests.testssl.SSLConfigTestMockiavellian.test_ssl_mockiavellian_client_server_hostname?4(ClientStorage, factory, *_)
+tests.testssl.SSLConfigTestMockiavellian.test_ssl_mockiavellian_client_server_signed?4(ClientStorage, factory, *_)
+tests.testssl.SSLConfigTestMockiavellian.test_ssl_mockiavellian_server_no_ssl?4(factory, *_)
+tests.testssl.SSLConfigTestMockiavellian.test_ssl_mockiavellian_server_ssl_auth_dir?4(factory, *_)
+tests.testssl.SSLConfigTestMockiavellian.test_ssl_mockiavellian_server_ssl_auth_file?4(factory, *_)
+tests.testssl.SSLConfigTestMockiavellian.test_ssl_mockiavellian_server_ssl_no_auth?4(factory, *_)
+tests.testssl.SSLConfigTestMockiavellian.test_ssl_mockiavellian_server_ssl_pw?4(factory, *_)
+tests.testssl.args?4(*a, **kw)
+tests.testssl.client_cert?7
+tests.testssl.client_key?7
+tests.testssl.client_ssl?4(cafile=server_key, client_cert=client_cert, client_key=client_key, )
+tests.testssl.create_server?4(**ssl_settings)
+tests.testssl.here?7
+tests.testssl.pwfunc?7
+tests.testssl.server_cert?7
+tests.testssl.server_config?7
+tests.testssl.server_key?7
+tests.testssl.serverpw_cert?7
+tests.testssl.serverpw_key?7
+tests.testssl.ssl_client?4(**ssl_settings)
+tests.testssl.ssl_conf?4(**ssl_settings)
+tests.testssl.test_suite?4()
+tests.threaded.threaded_server_tests?7
+tests.utils.ServerProtocol.async_?4(*args)
+tests.utils.ServerProtocol.async_threadsafe?7
+tests.utils.ServerProtocol.call_soon_threadsafe?4(func, *args)
+tests.utils.ServerProtocol.close?4()
+tests.utils.ServerProtocol.closed?7
+tests.utils.ServerProtocol.method?7
+tests.utils.ServerProtocol?1(zs, protocol_version=best_protocol_version, addr='test-address')
+tests.utils.StorageServer.assert_calls?4(test, *argss)
+tests.utils.StorageServer.unpack_result?4(result)
+tests.utils.StorageServer?1(test, storage, protocol_version=b'Z' + best_protocol_version, **kw)
+util.Environment?1(argv0)
+util.parentdir?4(p, n=1)
+zconfig.ClientStorageConfig.open?4()
+zconfig.ClientStorageConfig?1(config)
+zconfig.client_ssl?4(section)
+zconfig.server_ssl?4(section)
+zconfig.ssl_config?4(section, server)
+zeoctl.main?4(args=None)

Mercurial Repositories > Pyramid Project / file comparison

comparison: ProjectPyramid/APIs/ZEO-5.2.2.api

ProjectPyramid/APIs/ZEO-5.2.2.api