rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
options, args = getopt.getopt(args, "C:", ["configure="]) | options, args = getopt.getopt(args, "dr:p:f:C:", ["configure=", "protocol=", "filename=", "realm"]) | def options(args): """Password-specific options loaded from regular ZEO config file.""" schema = ZConfig.loadSchema(os.path.join(os.path.dirname(ZEO.__file__), "schema.xml")) try: options, args = getopt.getopt(args, "C:", ["configure="]) except getopt.error, msg: usage(msg) config = None delete = False for k, v in op... |
delete = False | delete = 0 auth_protocol = None auth_db = "" auth_realm = None | def options(args): """Password-specific options loaded from regular ZEO config file.""" schema = ZConfig.loadSchema(os.path.join(os.path.dirname(ZEO.__file__), "schema.xml")) try: options, args = getopt.getopt(args, "C:", ["configure="]) except getopt.error, msg: usage(msg) config = None delete = False for k, v in op... |
delete = True if config is None: usage("Must specifiy configuration file") | delete = 1 if k == '-p' or k == '--protocol': auth_protocol = v if k == '-f' or k == '--filename': auth_db = v if k == '-r' or k == '--realm': auth_realm = v if config is not None: if auth_protocol or auth_db: usage("Conflicting options; use either -C *or* -p and -f") auth_protocol = config.zeo.authentication_protocol... | def options(args): """Password-specific options loaded from regular ZEO config file.""" schema = ZConfig.loadSchema(os.path.join(os.path.dirname(ZEO.__file__), "schema.xml")) try: options, args = getopt.getopt(args, "C:", ["configure="]) except getopt.error, msg: usage(msg) config = None delete = False for k, v in op... |
return config.zeo, delete, username, password | return auth_protocol, auth_db, auth_realm, delete, username, password | def options(args): """Password-specific options loaded from regular ZEO config file.""" schema = ZConfig.loadSchema(os.path.join(os.path.dirname(ZEO.__file__), "schema.xml")) try: options, args = getopt.getopt(args, "C:", ["configure="]) except getopt.error, msg: usage(msg) config = None delete = False for k, v in op... |
options, delete, username, password = options(args) p = options.authentication_protocol | p, auth_db, auth_realm, delete, username, password = options(args) | def main(args=None): options, delete, username, password = options(args) p = options.authentication_protocol if p is None: usage("ZEO configuration does not specify authentication-protocol") if p == "digest": from ZEO.auth.auth_digest import DigestDatabase as Database elif p == "srp": from ZEO.auth.auth_srp import SRPD... |
if options.authentication_database is None: | else: raise ValueError, "Unknown database type %r" % p if auth_db is None: | def main(args=None): options, delete, username, password = options(args) p = options.authentication_protocol if p is None: usage("ZEO configuration does not specify authentication-protocol") if p == "digest": from ZEO.auth.auth_digest import DigestDatabase as Database elif p == "srp": from ZEO.auth.auth_srp import SRPD... |
db = Database(options.authentication_database) | db = Database(auth_db, auth_realm) | def main(args=None): options, delete, username, password = options(args) p = options.authentication_protocol if p is None: usage("ZEO configuration does not specify authentication-protocol") if p == "digest": from ZEO.auth.auth_digest import DigestDatabase as Database elif p == "srp": from ZEO.auth.auth_srp import SRPD... |
main(sys.argv) | main(sys.argv[1:]) | def main(args=None): options, delete, username, password = options(args) p = options.authentication_protocol if p is None: usage("ZEO configuration does not specify authentication-protocol") if p == "digest": from ZEO.auth.auth_digest import DigestDatabase as Database elif p == "srp": from ZEO.auth.auth_srp import SRPD... |
def _setDB(self, odb=None): | def _setDB(self, odb): | def _setDB(self, odb=None): """Begin a new transaction. |
self._db._closeConnection(self) self._db=self._storage=self._tmp=None | db=self._db self._db=self._storage=self._tmp=self.new_oid=None db._closeConnection(self) | def close(self): self._incrgc() self._db._closeConnection(self) self._db=self._storage=self._tmp=None |
zconf.monitor_address = monitor | zconf.monitor_address = ("", 42000) | def startServer(self, create=1, index=0, read_only=0, ro_svr=0): addr = self.addr[index] zLOG.LOG("testZEO", zLOG.INFO, "startServer(create=%d, index=%d, read_only=%d) @ %s" % (create, index, read_only, addr)) path = "%s.%d" % (self.file, index) sconf = self.getConfig(path, create, read_only) zconf = forker.ZEOConfig(a... |
invalidate=self._cache.invalidate for oid in oids: invalidate(oid, src) | vlen = pack(">H", len(src)) for oid in oids: self._tfile.write("i%s%s%s" % (oid, vlen, src)) | def abortVersion(self, src, transaction): if transaction is not self._transaction: raise POSException.StorageTransactionError(self, transaction) self._lock_acquire() try: oids=self._call('abortVersion', src, self._serial) invalidate=self._cache.invalidate for oid in oids: invalidate(oid, src) return oids finally: self.... |
for oid in oids: invalidate(oid, src) | for oid in oids: self._tfile.write("i%s%s%s" % (oid, vlen, src)) | def commitVersion(self, src, dest, transaction): if transaction is not self._transaction: raise POSException.StorageTransactionError(self, transaction) self._lock_acquire() try: oids=self._call('commitVersion', src, dest, self._serial) invalidate=self._cache.invalidate if dest: # just invalidate our version data for oi... |
for oid in oids: invalidate(oid, dest) | for oid in oids: self._tfile.write("i%s%s%s" % (oid, vlen, dest)) | def commitVersion(self, src, dest, transaction): if transaction is not self._transaction: raise POSException.StorageTransactionError(self, transaction) self._lock_acquire() try: oids=self._call('commitVersion', src, dest, self._serial) invalidate=self._cache.invalidate if dest: # just invalidate our version data for oi... |
write(oid+pack(">HI", len(version), len(data))+version) write(data) | buf = string.join(("s", oid, pack(">HI", len(version), len(data)), version, data), "") write(buf) | def store(self, oid, serial, data, version, transaction): if transaction is not self._transaction: raise POSException.StorageTransactionError(self, transaction) self._lock_acquire() try: serial=self._call.sendMessage('storea', oid, serial, data, version, self._serial) write=self._tfile.write write(oid+pack(">HI", len(... |
oid=read(8) s=seriald[oid] h=read(6) vlen, dlen = unpack(">HI", h) if vlen: v=read(vlen) else: v='' p=read(dlen) if len(p) != dlen: raise ClientStorageError, ( "Unexpected end of file in client storage " "temporary file." ) if s==ResolvedSerial: cache.invalidate(oid, v) else: update(oid, s, v, p) i=i+14+vlen+dlen | opcode=read(1) if opcode == "s": oid=read(8) s=seriald[oid] h=read(6) vlen, dlen = unpack(">HI", h) if vlen: v=read(vlen) else: v='' p=read(dlen) if len(p) != dlen: raise ClientStorageError, ( "Unexpected end of file in client storage " "temporary file." ) if s==ResolvedSerial: cache.invalidate(oid, v) else: update(oid... | def tpc_finish(self, transaction, f=None): self._lock_acquire() try: if transaction is not self._transaction: return if f is not None: f() |
if self.getpids(): | if not self.getpids(): | def stop_server(self): self.kill(pids=self.getpids()) # XXX Wait for the pidfile to disappear; not really clean. # Needed since we're not actually waiting for the ZEO server # process to exit (it's a grandchild, not a child). It we # don't wait, there's a race condition between one test and # the next -- if the ZEO se... |
import __main__ __main__.__builtins__.get_transaction=get_transaction | import __builtin__ __builtin__.get_transaction=get_transaction del __builtin__ | def free_transaction(_id=thread.get_ident, _t=_t): id = _id() try: del _t[id] except KeyError: pass |
fi.seek(22) | fi.seek(23) | def __init__(self, storage='', size=20000000, client=None, var=None): |
f.seek(8, 1) | f.seek(p+8) | def invalidate(self, oid, version): self._acquire() try: p = self._get(oid, None) if p is None: return None f = self._f[p < 0] ap = abs(p) f.seek(ap) h = f.read(8) if h != oid: return f.seek(8, 1) # Dang, we shouldn't have to do this. Bad Solaris & NT if version: f.write('n') else: del self._index[oid] f.write('i') fin... |
t=getattr(con._cache, attr) m[0]=m[0]+t m[1]=m[1]+1 | t = getattr(con._cache, attr) m[0] += t m[1] += 1 | def f(con, m=m, attr=attr): t=getattr(con._cache, attr) m[0]=m[0]+t m[1]=m[1]+1 |
detail[c] = detail[c] + 1 | detail[c] += 1 | def f(con, detail=detail, have_detail=detail.has_key): for oid, ob in con._cache.items(): module = getattr(ob.__class__, '__module__', '') module = module and '%s.' % module or '' c = "%s%s" % (module, ob.__class__.__name__) if have_detail(c): detail[c] = detail[c] + 1 else: detail[c] = 1 |
m[0] = m[0] + con._cache.cache_non_ghost_count | m[0] += con._cache.cache_non_ghost_count | def f(con, m=m): m[0] = m[0] + con._cache.cache_non_ghost_count |
SizedMessageAsyncConnection.__init__(self, s, {}) | SizedMessageAsyncConnection.__init__(self, s, s.getpeername(), {}) | def finishConnect(self, s): SizedMessageAsyncConnection.__init__(self, s, {}) |
tvindex=self._tvindex | def commitVersion(self, src, dest, transaction): # We are going to commit by simply storing back pointers. if transaction is not self._transaction: raise POSException.StorageTransactionError(self, transaction) self._a() try: file=self._file read=file.read seek=file.seek tfile=self._tfile write=tfile.write tappend=sel... | |
self._tvindex[src]=0 | tvindex[src]=0 | def commitVersion(self, src, dest, transaction): # We are going to commit by simply storing back pointers. if transaction is not self._transaction: raise POSException.StorageTransactionError(self, transaction) self._a() try: file=self._file read=file.read seek=file.seek tfile=self._tfile write=tfile.write tappend=sel... |
if self._nextpos: self._file.truncate(self._nextpos) | if self._nextpos: self._file.truncate(self._pos) self._nextpos=0 | def _abort(self): if self._nextpos: self._file.truncate(self._nextpos) |
id=thread.get_ident() | id=get_id() | def get_transaction(): id=thread.get_ident() try: theTransaction=theTransactions[id] except KeyError: theTransactions[id]=theTransaction=Transaction() return theTransaction |
id=thread.get_ident() | id=get_id() | def abort(self): |
print sys.path | def main(): import sys, getopt name_of_test = '' opts, args = getopt.getopt(sys.argv[1:], 'n:') for flag, val in opts: if flag == '-n': name_of_test = val if args: print "Did not expect arguments. Got %s" % args return 0 tests = makeTestSuite(name_of_test) runner = unittest.TextTestRunner() runner.run(tests) | |
self.assert_(not self._storage.is_connected()) zLOG.LOG("testZEO", zLOG.INFO, "WHY DOES THIS HANG???") | def checkReconnectUpgrade(self): # A fallback client reconnects from a read-only to a # read-write server | |
self._startServer(create=0) self.pollUp() self._dostore() | def checkReconnectUpgrade(self): # A fallback client reconnects from a read-only to a # read-write server | |
__version__='$Revision: 1.5 $'[11:-2] | __version__='$Revision: 1.6 $'[11:-2] | def info(RESPONSE): RESPONSE['Content-type']= 'text/plain' |
def __init__(self, file_name, create=0, read_only=0, stop=None, base=None): | def __init__(self, file_name, create=0, read_only=0, stop=None): | def __init__(self, file_name, create=0, read_only=0, stop=None, base=None): |
self._base=base | def __init__(self, file_name, create=0, read_only=0, stop=None, base=None): | |
try: try: return self._load(oid, version, self._index, self._file) except: if self._base is not None: return self._base.load(oid, version) raise | try: return self._load(oid, version, self._index, self._file) | def load(self, oid, version, _stuff=None): self._lock_acquire() try: try: return self._load(oid, version, self._index, self._file) except: if self._base is not None: return self._base.load(oid, version) raise finally: self._lock_release() |
for version in self._vindex.keys()[:max]: | keys=self._vindex.keys() if max is not None: keys=keys[:max] for version in keys: | def versions(self, max=None): r=[] a=r.append for version in self._vindex.keys()[:max]: if self.versionEmpty(version): continue a(version) if max and len(r) >= max: return r |
if self.filter is None or self.filter(dict): | if dict is not None and (self.filter is None or self.filter(dict)): | def search(self): """Search for another record.""" dict = self._readnext() if self.filter is None or self.filter(dict): if self.i >= self.first: self.results.append(dict) self.i += 1 |
def checkTcpAbortAfterCommit(self): | def checkTpcAbortAfterCommit(self): | def checkTcpAbortAfterCommit(self): obj = StubObject() self.datamgr.add(obj) oid = obj._p_oid |
self.assert_(msg.startswith("getTransaction() is deprecated.")) | self.assert_( msg.startswith("setLocalTransaction() is deprecated.") or msg.startswith("getTransaction() is deprecated.")) | def checkLocalTransactions(self): # Test of transactions that apply to only the connection, # not the thread. conn1 = self._db.open() conn2 = self._db.open() hook = WarningsHook() hook.install() try: conn1.setLocalTransaction() conn2.setLocalTransaction() r1 = conn1.root() r2 = conn2.root() if r1.has_key('item'): del r... |
recover(inp, outp, verobse, partial, force, pack) | recover(inp, outp, verbose, partial, force, pack) | def main(): try: opts, (inp, outp) = getopt.getopt(sys.argv[1:], 'fv:pP:') except getopt.error: die() print __doc__ % argv[0] force = partial = verbose = 0 pack = None for opt, v in opts: if opt == '-v': verbose = int(v) elif opt == '-p': partial = 1 elif opt == '-f': force = 1 elif opt == '-P': pack = time.time() - f... |
wait_for_server_on_starup=1): | wait_for_server_on_startup=1): | def __init__(self, connection, storage='1', cache_size=20000000, name='', client='', debug=0, var=None, min_disconnect_poll=5, max_disconnect_poll=300, wait_for_server_on_starup=1): |
self._wait_for_server_on_starup=wait_for_server_on_starup | self._wait_for_server_on_startup=wait_for_server_on_startup | def __init__(self, connection, storage='1', cache_size=20000000, name='', client='', debug=0, var=None, min_disconnect_poll=5, max_disconnect_poll=300, wait_for_server_on_starup=1): |
if not self._call.connect(not self._wait_for_server_on_starup): | if not self._call.connect(not self._wait_for_server_on_startup): | def _startup(self): |
def undoInfo(self, first, last, specification): | def undoInfo(self, first=0, last=-20, specification=None): | def undoInfo(self, first, last, specification): self._lock_acquire() try: return self._call('undoInfo', first, last, specification) finally: self._lock_release() |
self._file=file=open(file_name,'w+b') self._file.write(packed_version) self._pos=4 self._oid='\0\0\0\0\0\0\0\0' return if os.path.exists(file_name): | file=open(file_name,'w+b') file.write(packed_version) else: | def __init__(self, file_name, create=0, read_only=0, stop=None): |
else: if read_only: raise ValueError, "can\'t create a read-only file" file=open(file_name,'w+b') | def __init__(self, file_name, create=0, read_only=0, stop=None): | |
INSTANCE_HOME=os.environ.get('INSTANCE_HOME', directory(me, 4)) | if os.environ.has_key('INSTANCE_HOME'): INSTANCE_HOME=os.environ['INSTANCE_HOME'] elif os.path.isdir(os.path.join(directory(me, 4),'var')): INSTANCE_HOME=directory(me, 4) else: INSTANCE_HOME=os.getcwd() if os.path.isdir(os.path.join(INSTANCE_HOME, 'var')): var=os.path.join(INSTANCE_HOME, 'var') else: var=INSTANCE_HOME | def main(argv): me=argv[0] sys.path[:]==filter(None, sys.path) sys.path.insert(0, directory(me, 2)) args=[] last='' for a in argv[1:]: if (a[:1] != '-' and string.find(a, '=') > 0 and last != '-S' # lame, sorry ): a=string.split(a,'=') os.environ[a[0]]=string.join(a[1:],'=') continue args.append(a) last=a INSTANCE_HO... |
os.path.join(INSTANCE_HOME, 'var', 'ZEO_SERVER.pid') | os.path.join(var, 'ZEO_SERVER.pid') | def main(argv): me=argv[0] sys.path[:]==filter(None, sys.path) sys.path.insert(0, directory(me, 2)) args=[] last='' for a in argv[1:]: if (a[:1] != '-' and string.find(a, '=') > 0 and last != '-S' # lame, sorry ): a=string.split(a,'=') os.environ[a[0]]=string.join(a[1:],'=') continue args.append(a) last=a INSTANCE_HO... |
opts, args = getopt.getopt(args, 'p:Dh:U:sS:u:') fs=os.path.join(INSTANCE_HOME, 'var', 'Data.fs') | opts, args = getopt.getopt(args, 'p:Ddh:U:sS:u:') fs=os.path.join(var, 'Data.fs') | def main(argv): me=argv[0] sys.path[:]==filter(None, sys.path) sys.path.insert(0, directory(me, 2)) args=[] last='' for a in argv[1:]: if (a[:1] != '-' and string.find(a, '=') > 0 and last != '-S' # lame, sorry ): a=string.split(a,'=') os.environ[a[0]]=string.join(a[1:],'=') continue args.append(a) last=a INSTANCE_HO... |
debug=0 | debug=detailed=0 | def main(argv): me=argv[0] sys.path[:]==filter(None, sys.path) sys.path.insert(0, directory(me, 2)) args=[] last='' for a in argv[1:]: if (a[:1] != '-' and string.find(a, '=') > 0 and last != '-S' # lame, sorry ): a=string.split(a,'=') os.environ[a[0]]=string.join(a[1:],'=') continue args.append(a) last=a INSTANCE_HO... |
try: from ZServer.medusa import asyncore sys.modules['asyncore']=asyncore except: pass | import fap | def main(argv): me=argv[0] sys.path[:]==filter(None, sys.path) sys.path.insert(0, directory(me, 2)) args=[] last='' for a in argv[1:]: if (a[:1] != '-' and string.find(a, '=') > 0 and last != '-S' # lame, sorry ): a=string.split(a,'=') os.environ[a[0]]=string.join(a[1:],'=') continue args.append(a) last=a INSTANCE_HO... |
__builtins__.__debug__=debug | def main(argv): me=argv[0] sys.path[:]==filter(None, sys.path) sys.path.insert(0, directory(me, 2)) args=[] last='' for a in argv[1:]: if (a[:1] != '-' and string.find(a, '=') > 0 and last != '-S' # lame, sorry ): a=string.split(a,'=') os.environ[a[0]]=string.join(a[1:],'=') continue args.append(a) last=a INSTANCE_HO... | |
import ZEO.StorageServer, asyncore storages={} for o, v in opts: if o=='-S': n, m = string.split(v,'=') if string.find(m,':'): m, a = string.split(m,':') else: a=n storages[n]=get_storage(m,a) if not storages: import ZODB.FileStorage storages['1']=ZODB.FileStorage.FileStorage(fs) | def main(argv): me=argv[0] sys.path[:]==filter(None, sys.path) sys.path.insert(0, directory(me, 2)) args=[] last='' for a in argv[1:]: if (a[:1] != '-' and string.find(a, '=') > 0 and last != '-S' # lame, sorry ): a=string.split(a,'=') os.environ[a[0]]=string.join(a[1:],'=') continue args.append(a) last=a INSTANCE_HO... | |
import signal signal.signal(signal.SIGTERM, lambda sig, frame, s=storages: shutdown(s) ) signal.signal(signal.SIGINT, lambda sig, frame, s=storages: shutdown(s, 0) ) signal.signal(signal.SIGHUP, rotate_logs_handler) finally: pass items=storages.items() items.sort() for kv in items: LOG('ZEO Server', INFO, 'Serving %... | import ZEO.StorageServer, asyncore storages={} for o, v in opts: if o=='-S': n, m = string.split(v,'=') if string.find(m,':'): m, a = string.split(m,':') else: a=n storages[n]=get_storage(m,a) if not storages: import ZODB.FileStorage storages['1']=ZODB.FileStorage.FileStorage(fs) try: import signal signal.signal... | def main(argv): me=argv[0] sys.path[:]==filter(None, sys.path) sys.path.insert(0, directory(me, 2)) args=[] last='' for a in argv[1:]: if (a[:1] != '-' and string.find(a, '=') > 0 and last != '-S' # lame, sorry ): a=string.split(a,'=') os.environ[a[0]]=string.join(a[1:],'=') continue args.append(a) last=a INSTANCE_HO... |
self.storage._log("store error: %s, %s" % exc_info[:2], zLOG.ERROR, error=exc_info) | log("store error: %s, %s" % exc_info[:2], zLOG.ERROR, error=exc_info) | def store(self, oid, serial, data, version): try: newserial = self.storage.store(oid, serial, data, version, self.txn) except TransactionError, err: # Storage errors are passed to the client newserial = err except Exception: # Unexpected storage errors are logged and passed to the client exc_info = sys.exc_info() self.... |
self.storage._log(msg, zLOG.ERROR) | log(msg, zLOG.ERROR) | def store(self, oid, serial, data, version): try: newserial = self.storage.store(oid, serial, data, version, self.txn) except TransactionError, err: # Storage errors are passed to the client newserial = err except Exception: # Unexpected storage errors are logged and passed to the client exc_info = sys.exc_info() self.... |
success = self.try_connecting() | success = self.try_connecting(attempt_timeout) | def run(self): delay = self.tmin success = 0 while not self.stopped: success = self.try_connecting() if not self.one_attempt.isSet(): self.one_attempt.set() if success > 0: break time.sleep(delay) delay = min(delay*2, self.tmax) log("CT: exiting thread: %s" % self.getName()) |
def try_connecting(self): | def try_connecting(self, timeout): | def try_connecting(self): """Try connecting to all self.addrlist addresses. |
deadline = time.time() + timeout wrappers = self._create_wrappers() for wrap in wrappers.keys(): if wrap.state == "notified": return 1 try: if time.time() > deadline: return 0 r = self._connect_wrappers(wrappers, deadline) if r is not None: return r if time.time() > deadline: return 0 r = self._fallback_wrappers(wrappe... | def try_connecting(self): """Try connecting to all self.addrlist addresses. | |
return 1 | wrappers[wrap] = wrap return wrappers | def try_connecting(self): """Try connecting to all self.addrlist addresses. |
return wrappers def _connect_wrappers(self, wrappers, deadline): | def try_connecting(self): """Try connecting to all self.addrlist addresses. | |
assert not wrappers return 0 | def try_connecting(self): """Try connecting to all self.addrlist addresses. | |
prfactory = PersistentReferenceFactory() | def tryToResolveConflict(self, oid, committedSerial, oldSerial, newpickle, committedData=''): #class_tuple, old, committed, newstate = ('',''), 0, 0, 0 try: file = StringIO(newpickle) unpickler = Unpickler(file) prfactory = PersistentReferenceFactory() unpickler.persistent_load = prfactory.persistent_load class_tuple =... | |
klass = _classFactory(class_tuple[0], class_tuple[1]) | klass = load_class(class_tuple) | def tryToResolveConflict(self, oid, committedSerial, oldSerial, newpickle, committedData=''): #class_tuple, old, committed, newstate = ('',''), 0, 0, 0 try: file = StringIO(newpickle) unpickler = Unpickler(file) prfactory = PersistentReferenceFactory() unpickler.persistent_load = prfactory.persistent_load class_tuple =... |
def testExceptionInTpcFinish(self): for sub in self.sub1, self.sub2: sub._p_jar = SubTransactionJar(errors='tpc_finish') sub.modify(nojar=1) self.nosub1.modify() try: get_transaction().commit() except TestTxnException: pass except Transaction.POSException.TransactionError: pass assert Transaction.hosed == 1 Trans... | def testExceptionInTpcFinish(self): | |
def BUGtestExceptionInSubTpcBegin(self): """ bug, we short circuit on notifying objects in previous subtransactions of the transaction outcome untested but this probably also applies to error in tpc_finish, as the error has to do with not checking the implicit sub transaction commit done when closing the outer transa... | def testExceptionInSubAbortSub(self): self.sub1._p_jar = SubTransactionJar(errors='commit_sub') self.sub1.modify(nojar=1) get_transaction().commit(1) | |
for sub in self.sub1, self.sub2: sub._p_jar = SubTransactionJar(errors='tpc_finish') sub.modify(nojar=1) self.nosub1.modify() try: get_transaction().commit() except TestTxnException: pass assert Transaction.hosed == 1 | objects = self.sub1, self.sub2, self.sub3, self.nosub1 for i in range(10): L = list(objects) random.shuffle(L) obj = L.pop() obj.modify() obj2 = L.pop() obj2._p_jar = SubTransactionJar(errors='tpc_finish') obj2.modify(nojar=1) try: get_transaction().commit() except TestTxnException: pass jars = {} for obj in object... | def testHoserStoppage(self): # must have errors in at least two jars to guarantee a failure for sub in self.sub1, self.sub2: sub._p_jar = SubTransactionJar(errors='tpc_finish') sub.modify(nojar=1) self.nosub1.modify() |
def deprecated_loop(*args, **kws): import warnings warnings.warn("""\ ThreadedAsync.loop() called through sneaky asyncore.loop() rebinding. You should change your code to call ThreadedAsync.loop() explicitly.""", DeprecationWarning) loop(*args, **kws) | def deprecated_loop(*args, **kws): import warnings warnings.warn("""\ | |
asyncore.loop = deprecated_loop | asyncore.loop = loop | def deprecated_loop(*args, **kws): import warnings warnings.warn("""\ |
elif o=='-M': | elif o=='-L': | def main(args): opts, args = getopt.getopt(args, 'zd:n:Ds:L') z=s=None data=sys.argv[0] nrep=5 minimize=0 for o, v in opts: if o=='-n': nrep=string.atoi(v) elif o=='-d': data=v elif o=='-s': s=v elif o=='-z': global zlib import zlib z=compress elif o=='-M': minimize=1 elif o=='-D': global debug os.environ['STUPID_LOG_... |
if not (self._mvcc and self._setstate_noncurrent(obj)): self.getTransaction().register(obj) self._conflicts[obj._p_oid] = 1 raise ReadConflictError(object=obj) | self._load_before_or_conflict(obj) return | def _setstate(self, obj): # Helper for setstate(), which provides logging of failures. |
elif not (self._mvcc and self._setstate_noncurrent(obj)): self.getTransaction().register(obj) self._conflicts[obj._p_oid] = 1 raise ReadConflictError(object=obj) | else: self._load_before_or_conflict(obj) return | def _setstate(self, obj): # Helper for setstate(), which provides logging of failures. |
os.path.join(here, "releases", "ZODB3", "PUBLICATION.cfg")) | os.path.join(here, "PUBLICATION.cfg")) | def join(*parts): local_full_path = os.path.join(here, *parts) relative_path = posixpath.join(*parts) return local_full_path, relative_path |
context.scan("ZODB3", *join("releases", "ZODB3")) | context.scan("ZODB3", here, ".") | def join(*parts): local_full_path = os.path.join(here, *parts) relative_path = posixpath.join(*parts) return local_full_path, relative_path |
if os.name == "nt": | def get_port(): """Return a port that is not in use. Checks if a port is in use by trying to connect to it. Assumes it is not in use if connect raises an exception. Raises RuntimeError after 10 tries. """ for i in range(10): port = random.randrange(20000, 30000) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) ... | |
Returns the ZEO port, the test server port, and the pid. """ import ZEO.tests.winserver if addr is None: port = get_port() else: port = addr[1] script = ZEO.tests.winserver.__file__ if script.endswith('.pyc'): script = script[:-1] if ro_svr: prefix = (sys.executable, script, "-r") else: prefix = (sys.executable, script... | Returns the ZEO port, the test server port, and the pid. """ tmpfile = tempfile.mktemp() fp = open(tmpfile, 'w') fp.write(conf) fp.close() import ZEO.tests.zeoserver if addr is None: port = get_port() else: port = addr[1] script = ZEO.tests.zeoserver.__file__ if script.endswith('.pyc'): script = script[:-1] args = [... | def start_zeo_server(conf, addr=None, ro_svr=0): """Start a ZEO server in a separate process. |
else: | def start_zeo_server(conf, addr=None, ro_svr=0): """Start a ZEO server in a separate process. | |
class ZEOServerExit(asyncore.file_dispatcher): """Used to exit ZEO.StorageServer when run is done""" def writable(self): return 0 def readable(self): return 1 def handle_read(self): buf = self.recv(4) if buf: assert buf == "done" server.close_server() asyncore.socket_map.clear() def handle_close(self): server.close... | def shutdown_zeo_server(adminaddr): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect(adminaddr) ack = s.recv(1) zLOG.LOG('shutdownServer', zLOG.DEBUG, 'acked: %s' % ack) s.close() | def start_zeo_server(conf, addr=None, ro_svr=0): """Start a ZEO server in a separate process. |
def filter(desc, spec=specification.items()): get=desc.get for k, v in spec: if get(k, None) != v: return 0 return 1 | if specification: def filter(desc, spec=specification.items()): get=desc.get for k, v in spec: if get(k, None) != v: return 0 return 1 else: filter=None | def filter(desc, spec=specification.items()): get=desc.get for k, v in spec: if get(k, None) != v: return 0 return 1 |
SizedMessageAsyncConnection.__init__(self, s, s.getpeername(), {}) | SizedMessageAsyncConnection.__init__(self, s, '', {}) | def finishConnect(self, s): SizedMessageAsyncConnection.__init__(self, s, s.getpeername(), {}) |
args=dump(args,1) self.message_output(args) if self.__map: self.__Wakeup() else: self.readLoop() while 1: r=self._read() c=r[:1] if c=='R': if r=='RN.': return None return loads(r[1:]) if c=='E': r=loads(r[1:]) if type(r) is TupleType: raise r[0], r[1] raise r oob=self._outOfBand if oob is not None: r=r[1:] if r=='N.... | self.__call_la() try: self._last_args=args=dump(args,1) self.message_output(args) if self.__map: self.__Wakeup() else: self.readLoop() while 1: r=self._read() c=r[:1] if c=='R': if r=='RN.': return None return loads(r[1:]) if c=='E': try: r=loads(r[1:]) except: raise UnUnPickleableError(r[1:]) if type(r) is TupleType... | def __call__(self, *args): args=dump(args,1) self.message_output(args) |
self.assertRaises(POSException.VersionError, self._storage.load, oid, 'bogus') | data, revid = self._storage.load(oid, 'bogus') assert pickle.loads(data) == 11 | def checkVersionedLoadErrors(self): oid = self._storage.new_oid() version = 'test-version' revid = self._dostore(oid, data=11) revid = self._dostore(oid, revid=revid, data=12, version=version) # Try to load a bogus oid self.assertRaises(KeyError, self._storage.load, self._storage.new_oid(), '') # Try to load a bogus ve... |
assert self._storage.versionEmpty('') | def checkVersionEmpty(self): # Before we store anything, these versions ought to be empty version = 'test-version' assert self._storage.versionEmpty('') assert self._storage.versionEmpty(version) # Now store some objects oid = self._storage.new_oid() revid = self._dostore(oid, data=11) revid = self._dostore(oid, revid=... | |
assert not self._storage.versionEmpty('') | def checkVersionEmpty(self): # Before we store anything, these versions ought to be empty version = 'test-version' assert self._storage.versionEmpty('') assert self._storage.versionEmpty(version) # Now store some objects oid = self._storage.new_oid() revid = self._dostore(oid, data=11) revid = self._dostore(oid, revid=... | |
self.assertRaises(KeyError, self._storage.abortVersion, 'bogus', self._transaction) | def checkAbortVersionErrors(self): oid, version = self._setup_version() # Now abort a bogus version self._storage.tpc_begin(self._transaction) self.assertRaises(KeyError, self._storage.abortVersion, 'bogus', self._transaction) # And try to abort the empty version self.assertRaises(KeyError, self._storage.abortVersion, ... | |
self.assertRaises(KeyError, | self.assertRaises(POSException.VersionError, | def checkAbortVersionErrors(self): oid, version = self._setup_version() # Now abort a bogus version self._storage.tpc_begin(self._transaction) self.assertRaises(KeyError, self._storage.abortVersion, 'bogus', self._transaction) # And try to abort the empty version self.assertRaises(KeyError, self._storage.abortVersion, ... |
self.assertRaises(POSException.VersionError, self._storage.load, oid1, version2) | data, revid2 = self._storage.load(oid1, version2) assert pickle.loads(data) == 51 | def checkCommitToOtherVersion(self): oid1, version1 = self._setup_version('one') data, revid1 = self._storage.load(oid1, version1) assert pickle.loads(data) == 54 oid2, version2 = self._setup_version('two') data, revid2 = self._storage.load(oid2, version2) assert pickle.loads(data) == 54 # Let's make sure we can't get ... |
self.assertRaises(POSException.VersionError, self._storage.load, oid1, version1) | data, revid2 = self._storage.load(oid1, version1) assert pickle.loads(data) == 51 | def checkCommitToOtherVersion(self): oid1, version1 = self._setup_version('one') data, revid1 = self._storage.load(oid1, version1) assert pickle.loads(data) == 54 oid2, version2 = self._setup_version('two') data, revid2 = self._storage.load(oid2, version2) assert pickle.loads(data) == 54 # Let's make sure we can't get ... |
jar=self._p_jar if self._p_changed is None: jar.setstate(self) self.__dict__[key]=value if jar is not None: try: get_transaction().register(self) self._p_changed=1 except: pass | jar=self._p_jar if jar is None: self.__dict__[key]=value return d=self.__dict__ if changed is None: d['_p_changed']=1 jar.setstate(self) d[key]=value try: get_transaction().register(self) d['_p_changed']=1 except: pass | def __setattr__(self,key,value): ' ' k=key[:3] if k=='_p_' or k=='_v_': self.__dict__[key]=value return |
self._r() | def open(self, version='', transaction=None, temporary=0, force=None, waitflag=1): """Return a object space (AKA connection) to work in | |
read=self._file.read h=read(DATA_HDR_LEN) doid,serial,sprev,stloc,vlen,splen = unpack(DATA_HDR, h) | h = self._file.read(DATA_HDR_LEN) doid, serial, sprev, stloc, vlen, splen = unpack(DATA_HDR, h) | def _getVersion(self, oid, pos): self._file.seek(pos) read=self._file.read h=read(DATA_HDR_LEN) doid,serial,sprev,stloc,vlen,splen = unpack(DATA_HDR, h) assert doid == oid if vlen: h=read(16) return read(vlen), h[:8] else: return '','' |
h=read(16) return read(vlen), h[:8] | h = self._file.read(16) return self._file.read(vlen), h[:8] | def _getVersion(self, oid, pos): self._file.seek(pos) read=self._file.read h=read(DATA_HDR_LEN) doid,serial,sprev,stloc,vlen,splen = unpack(DATA_HDR, h) assert doid == oid if vlen: h=read(16) return read(vlen), h[:8] else: return '','' |
self._file.seek(pos+8) return self._file.read(8) | self._file.seek(pos) h = self._file.read(16) assert oid == h[:8] return h[8:] | def _getSerial(self, oid, pos): self._file.seek(pos+8) return self._file.read(8) |
if pre: version, snv = self._getVersion(oid, pre) else: version, snv = '', '' | if not pre: return '', 0, '', '', ipos version, snv = self._getVersion(oid, pre) | def _transactionalUndoRecord(self, oid, pos, serial, pre, version): """Get the indo information for a data record |
pos=pos+dlen | pos += dlen | def _txn_undo_write(self, tpos, tid): # a helper function to write the data records for transactional undo |
raise ReadConflictError(oid) | raise ReadConflictError(object=object) | def commit(self, object, transaction): if object is self: # We registered ourself. Execute a commit action, if any. if self.__onCommitActions is not None: method_name, args, kw = self.__onCommitActions.pop(0) getattr(self, method_name)(transaction, *args, **kw) return oid = object._p_oid if self._conflicts.has_key(oi... |
cn = self._connection if cn is None: | if self._ready.isSet(): break log2(INFO, "Wait for cache verification to finish") if self._connection is None: | def _wait(self): # Wait for a connection to be established. self._rpc_mgr.connect(sync=1) # When a synchronous connect() call returns, there is # a valid _connection object but cache validation may # still be going on. This code must wait until validation # finishes, but if the connection isn't a zrpc async # connecti... |
cn.pending(30) if self._ready.isSet(): break log2(INFO, "Wait for cache verification to finish") | self._connection.pending(30) | def _wait(self): # Wait for a connection to be established. self._rpc_mgr.connect(sync=1) # When a synchronous connect() call returns, there is # a valid _connection object but cache validation may # still be going on. This code must wait until validation # finishes, but if the connection isn't a zrpc async # connecti... |
tl=U64(stl) | tl=u64(stl) | def read_transaction_header(file, pos, file_size): # Read the transaction record file.seek(pos) h = file.read(23) if len(h) < 23: raise EOFError tid, stl, status, ul, dl, el = unpack(">8s8scHHH",h) if el < 0: el=t32-el tl=U64(stl) if status=='c': raise EOFError if pos+(tl+8) > file_size: error("bad transaction leng... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.