def create_event(self, event_kind, operation, event_data):
#
data = dict({
'event_kind': event_kind,
'operation': operation,
'event_data': event_data
})
data['owner_guid'] = self.me.hex()
data['model'] = 'Event'
value = data
from datetime import datetime
key = data['event_kind'] + ';;' + data['operation'] + datetime.now(
).isoformat()
try:
o_item_hk = self.myevts.insert(key=key, value=value)
except:
self.cherry.response.status = 409
return b'ERROR in insert'
self.cherry.response.status = 201
if o_item_hk:
try:
hex_str = guid_int_to_hex(o_item_hk)
return hex_str.encode()
except:
return b'ERROR converting hash key'
else:
return b'null'
def POST(self):
body = self.cherry.request.body.read()
data = {}
try:
# decode the body
body = body.decode()
data = json.loads(body)
except:
# todo improve whole-site err handling
print('ERR in DECODE data from body')
self.cherry.response.status = 409
return b'ERROR in decode parse'
for item in self.required_fields:
if item not in data:
print('REQUIRED FIELD', item)
data['owner_guid'] = self.me.hex()
data['model'] = 'Portfolio'
value = data
from datetime import datetime
key = data['title'] + ';' + datetime.now().isoformat()
try:
o_item_hk = self.mygigs.insert(key=key, value=value)
except:
self.cherry.response.status = 409
return b'ERROR in inserting'
self.cherry.response.status = 201
if o_item_hk:
try:
hex_str = guid_int_to_hex(o_item_hk)
return hex_str.encode()
except:
return b'ERROR converting hash key'
else:
return b'null'
def render_dht(self):
for peer in self._dhf.peers:
ip4 = peer['host']
if ip4 in self.peers:
data = self.peers[ip4]
else:
data = dict()
data['guid'] = guid_int_to_hex(peer['id'])
data['udp_port'] = peer['port']
data['ip4'] = ip4
self.peers[ip4] = data
def on_pushed_ip4_peer(self, data, hk_int=None, hk_owner_bin=None):
if self.dhf.indexer:
logger('have INDEXER')
try:
self.dhf.indexer.index_on(cdx.guid_int_to_hex(hk_int), data)
except Exception as e:
# logger('ERROR indexing', str(e))
pass
if 'ert:boot_to' in data:
host = data['ert:boot_to']['h']
port = data['ert:boot_to']['p']
# logger(' + + \n\nPEER DHT BOOT TO:', host, port)
self.dhf.direct_push_pubkey(host, port)
self.dhf.boot_to(host, port)
# on cdn url post update
if 'cdn_url' in data and 'hk_hex' in data and self.dhf.cdn:
if self.dhf.cdn.cdn_url in data['cdn_url']:
# logger('CDN ITSELF')
return
# logger('PUSHED RESOURCE ON CDN %s?hkey=%s' % (data['cdn_url'], data['hk_hex']))
meta_bts = self.dhf.cdn.get_remote_meta_data(hkey=data['hk_hex'], cdn_url=data['cdn_url'])
if not meta_bts:
return None
import json
try:
meta_dict = json.loads(meta_bts.decode())
except Exception as e:
print('META_BTS decode ERR', e)
return None
try:
self.dhf.cdn.set_local_meta_data(hkey=meta_dict['hkey'], data=meta_dict)
except Exception as e:
# logger('meta err', e)
pass
if 'fext' in meta_dict and self.dhf.cdn:
# logger('SETTING', meta_dict)
try:
bts = self.dhf.cdn.get_remote_data(
cdn_url=data['cdn_url'],
hkey=meta_dict['hkey'])
if bts:
self.dhf.cdn.set_local_data(hkey=meta_dict['hkey'],
fext=meta_dict['fext'],
bts=bts)
else:
# logger('no BYTES from REMOTE')
raise ValueError('no BYTES from REMOTE')
except Exception as e:
raise e
def POST(self):
body = self.cherry.request.body.read()
data = {}
try:
# decode the body
body = body.decode()
# sanitize
# body = bleach.clean(body)
data = json.loads(body)
except:
# todo improve whole-site err handling
print('ERR in DECODE data from body')
self.cherry.response.status = 409
return b'ERROR in decode parse'
for item in self.required_fields:
if item not in data:
print('REQUIRED FIELD', item)
s = 'ERROR %s field required!' % str(item)
return s.encode()
data['owner_guid'] = self.me.hex()
data['model'] = 'Gig'
value = data
from datetime import datetime
key = {
self.collection_name:
data['title'] + ';' + datetime.now().isoformat()
}
o_item = self.mygigs.dlitem_dict.get(key)
if o_item:
if o_item.deleted:
self.deleted_gigs.delete(key)
try:
o_item_hk = self.mygigs.insert(key=key, value=value)
except:
self.cherry.response.status = 409
return b'ERROR in insert'
self.cherry.response.status = 201
if o_item_hk:
try:
hex_str = guid_int_to_hex(o_item_hk)
return hex_str.encode()
except:
return b'ERROR converting hash key'
else:
return b'null'
def index_or_unindex_data(self, hk_int, data, hk_owner_bin=None):
hk_hex = guid_int_to_hex(hk_int)
# hk_own_hex = None
# # this is msg owner sender not guid owner
# if hk_owner_bin:
# hk_own_hex = guid_bin_to_hex2(hk_owner_bin)
#
# # profile key->val
#
# if 'k' in data:
# if 'profile:key' in data['k']:
# key_name = data['k']['profile:key']
# if key_name:
# if 'v' in data:
# if 'o' in data:
# own_guid = data['o']
# key_value = data['v']
# idxr = self.MODEL_INDEXERS['.Profile.key']
# if key_value:
# idxr.unindex(own_guid)
# idxr.index(own_guid, {'k': key_name, 'v': key_value})
#
# else:
# return
# docs
if 'value' in data:
value_data = data['value']
if not isinstance(value_data, dict):
return None
else:
return None
if 'model' in value_data:
if value_data['model'] in self.MODEL_INDEXERS:
model_name = value_data['model']
idxr = self.MODEL_INDEXERS.get(model_name)
if not idxr:
return None
#
if 'deleted' in value_data:
idxr.unindex(hk_hex)
return False
else:
idxr.index(hk_hex, value_data)
return True
return None
def pull(self, hk):
# logger('STORE HANDLER PULL', hk)
logger('LOCAL PULL DATA', hk)
pk_owner = None
t = self.store.get(hk)
if t:
try:
pk_owner, pk_signature, pk_value = self.store.get(hk)
revision, data = cdx.decode_bson_val(pk_value)
self.on_pull_handle(hk, data, hk_owner_bin=pk_owner)
self.dhf.indexer.index_on(cdx.guid_int_to_hex(hk), data, event='ON_PULL')
if self.ON_PUSH_GUID_KEY in data:
# logger('\n\n\n GUIDS REQUESTED \n\n\n')
v = data[self.ON_PUSH_GUID_KEY]
# logger(v)
return
if self.ON_PUSH_PEER_KEY in data:
# self.dhf.pus
v = data[self.ON_PUSH_PEER_KEY]
host = v['h']
port = v['p']
# logger('\n \n \n \n \n + + @ SEND PEER TO BOOT', host, port)
for item in self.dhf.peers:
try:
peer_host = item['host']
peer_port = item['port']
key = {'ert': 'boot_to'}
value = {'ert:boot_to': {'h': peer_host, 'p': peer_port}}
self.dhf.direct_push_pubkey(host, port)
self.dhf.direct_push(key, value, host, port)
# self.dhf.boot_to(peer_host, peer_port)
except Exception as e:
# logger('ERROR bootstaraping peers to requester', str(e))
pass
return
#? todo return ?
except Exception as e:
# logger('ON PULL DECODING FAIL', str(e))
pass
if not t:
self.on_pull_handle(hk, dict(), hk_owner_bin=pk_owner)
# self.on_pull_handle(hk, dict(), hk_owner_bin=pk_owner)
return self.store.get(hk)
def insert(self, peer):
if peer.id != self.id:
bucket_number = largest_differing_bit(self.id, peer.id)
peer_triple = peer.astriple()
with self.lock:
bucket = self.buckets[bucket_number]
if peer_triple in bucket:
bucket.pop(bucket.index(peer_triple))
elif len(bucket) >= self.bucket_size:
bucket.pop(0)
bucket.append(peer_triple)
host = peer_triple[0]
port = peer_triple[1]
guid = peer_triple[2]
host_port = '%s:%d' % (host, port)
if host_port not in self.host_port__host_port_binguid:
self.host_port__host_port_binguid[host_port] = (
host, port, guid_int_to_bts(guid))
self.host_port__host_port_hexguid[host_port] = (
host, port, guid_int_to_hex(guid))
def index_or_unindex_data(self, hk_int, data):
hk_hex = guid_int_to_hex(hk_int)
if 'value' in data:
value_data = data['value']
if not isinstance(value_data, dict):
return None
else:
return None
if 'model' in value_data:
if value_data['model'] in self.MODEL_INDEXERS:
model_name = value_data['model']
idxr = self.MODEL_INDEXERS.get(model_name)
if not idxr:
return None
#
if 'deleted' in value_data:
idxr.unindex(hk_hex)
return False
else:
idxr.index(hk_hex, value_data)
return True
return None
try:
ert_profile_ctl = main_profile(
http_webdir=http_webdir,
files_dir_name=config.static_files,
cdn_host=boot_cdn_host,
cdn_port=boot_cdn_port,
shared_profile_instance_id=args.shared_profile_instance_id)
ert = ert_profile_ctl
if args.upnp_attempt:
upnp.punch_port(udp_port, udp_port, args.if_name)
hex_guid, bin_guid = ert_profile_ctl.rsa_guid_hex_bin
int_guid = kadmini_codec.guid_bts_to_int(bin_guid)
bts_2 = kadmini_codec.guid_int_to_bts(int_guid)
hex2_guid = kadmini_codec.guid_int_to_hex(int_guid)
assert hex2_guid == hex_guid
#
storage_handle = store_handler.DHTStoreHandlerOne(
dht_sqlite_file=ert.dht_fb_fn,
pubkeys_sqlite_file=ert.dht_ref_pubkeys_fn,
)
# local_ip = upnp.get_my_ip()
# todo
from toolkit.tools import get_ip_address
local_ip = get_ip_address(args.if_name)
ip = local_ip
ert_profile_ctl.my_wan_ip = ip
ert_profile_ctl.my_lan_ip = ip