def raw_read_page(file):
try:
with open('db/' + file, 'r') as myfile:
return unpackage(myfile.read())
except:
time.sleep(0.0001)
return raw_read_page(file)
def recvall(client, data=''):
try:
data += client.recv(MAX_MESSAGE_SIZE)
except:
time.sleep(0.0004)
tools.log('not ready')
recvall(client, data)
if not data:
return 'broken connection'
if len(data) < 5: return recvall(client, data)
try:
length = int(data[0:5])
except:
return 'no length'
tries = 0
data = data[5:]
while len(data) < length:
try:
d = client.recv(MAX_MESSAGE_SIZE - len(data))
except: #dirty fix to get Macs to work.
return 'broken connection'
if not d:
return 'broken connection'
data += d
try:
data = unpackage(data)
except:
pass
return data
def recvall(client, data=''):
try:
data+=client.recv(MAX_MESSAGE_SIZE)
except:
time.sleep(0.0001)
tools.log('not ready')
recvall(client, data)
if not data:
return 'broken connection'
if len(data)<5: return recvall(client, data)
try:
length=int(data[0:5])
except:
return 'no length'
tries=0
data=data[5:]
while len(data)<length:
d=client.recv(MAX_MESSAGE_SIZE-len(data))
if not d:
return 'broken connection'
data+=d
try:
data=unpackage(data)
except:
pass
return data
def db_existence(key, DB):
n = str(key)
try:
a = unpackage(DB['db'].Get(n))
return not a == default_entry
except:
return False
def db_get(n, DB):
n = str(n)
try:
return unpackage(DB['db'].Get(n))
except:
db_put(n, default_entry, DB)
return db_get(n, DB)
def det_hash(x): # deterministically takes sha256 of dict, list, int, or string
def det_list(l): return '[%s]' % ','.join(map(det, sorted(l)))
def det_dict(x):
list_ = map(lambda p: det(p[0]) + ':' + det(p[1]), sorted(x.items()))
return '{%s}' % ','.join(list_)
def det(x): return {list: det_list, dict: det_dict}.get(type(x), str)(x)
return hashlib.sha256(det(unpackage(package(x)))).hexdigest()
def det_hash(x): # deterministically takes sha256 of dict, list, int, or string
def det_list(l):
return "[%s]" % ",".join(map(det, sorted(l)))
def det_dict(x):
list_ = map(lambda p: det(p[0]) + ":" + det(p[1]), sorted(x.items()))
return "{%s}" % ",".join(list_)
def det(x):
return {list: det_list, dict: det_dict}.get(type(x), str)(x)
return custom.hash_(det(unpackage(package(x))))
def det_hash(x):
"""Deterministically takes sha256 of dict, list, int, or string."""
def det_list(l): return '[%s]' % ','.join(map(det, sorted(l)))
def det_dict(x):
list_=map(lambda p: det(p[0]) + ':' + det(p[1]), sorted(x.items()))
return '{%s}' % ','.join(list_)
def det(x): return {list: det_list, dict: det_dict}.get(type(x), str)(x)
return hash_(det(unpackage(package(x))))
def can_unpack(o):
try:
unpackage(o)
return True
except:
return False
def can_unpack(o):
try:
unpackage(o)
return True
except:
return False
def get(key): return unpackage(rlp.decode(state.get(key))) def put(key, val): return state.update(key, rlp.encode(package(val)))
def det_hash(x):#deterministically hash
def det(x): return {list: (lambda l: '[%s]' % ','.join(map(det, sorted(l)))),
dict:(lambda x: '{%s}' % ','.join(map(lambda p: det(p[0]) + ':' + det(p[1]), sorted(x.items()))))}.get(type(x), str)(x)
return hashlib.sha256(det(unpackage(package(x)))).hexdigest()
def db_put(key, dic, DB={}):
dic = unpackage(package(dic)) #keeps it deterministic.
return s_to_db({'type': 'put', 'args': [str(key), dic]})
def get(key):
return unpackage(rlp.decode(state.get(key)))
def db_put(key, dic, DB={}):
dic=unpackage(package(dic))#keeps it deterministic.
return s_to_db({'type':'put', 'args':[str(key), dic]})
def raw_read_page(file):
try:
with open('db/'+file, 'r') as myfile: return unpackage(myfile.read())
except:
time.sleep(0.0001)
return raw_read_page(file)
