def doReportFailed(self, arg):
"""
Action method.
"""
if self.result_defer:
if arg:
events.send(
'private-key-share-failed',
dict(
global_id=global_id.UrlToGlobalID(self.remote_idurl),
remote_idurl=self.remote_idurl,
key_id=self.key_id,
reason=arg,
))
self.result_defer.errback(Exception(arg))
else:
if self.remote_identity is None:
events.send(
'private-key-share-failed',
dict(
global_id=global_id.UrlToGlobalID(
self.remote_idurl),
remote_idurl=self.remote_idurl,
key_id=self.key_id,
reason='remote id caching failed',
))
self.result_defer.errback(
Exception('remote id caching failed'))
else:
if self.ping_response is None:
events.send(
'private-key-share-failed',
dict(
global_id=global_id.UrlToGlobalID(
self.remote_idurl),
remote_idurl=self.remote_idurl,
key_id=self.key_id,
reason='remote node not responding',
))
self.result_defer.errback(
Exception('remote node not responding'))
else:
events.send(
'private-key-share-failed',
dict(
global_id=global_id.UrlToGlobalID(
self.remote_idurl),
remote_idurl=self.remote_idurl,
key_id=self.key_id,
reason='failed',
))
self.result_defer.errback(Exception('failed'))
def on_delete_file(newpacket):
# TODO: call verify_packet_ownership()
if not newpacket.Payload:
ids = [
newpacket.PacketID,
]
else:
ids = strng.to_text(newpacket.Payload).split('\n')
filescount = 0
dirscount = 0
lg.warn('going to erase files: %s' % ids)
customer_id = global_id.UrlToGlobalID(newpacket.OwnerID)
for pcktID in ids:
glob_path = global_id.ParseGlobalID(pcktID)
if not glob_path['customer']:
glob_path = global_id.ParseGlobalID(customer_id + ':' + pcktID)
if not glob_path['path']:
lg.err("got incorrect PacketID")
p2p_service.SendFail(newpacket, 'incorrect path')
return False
if customer_id != glob_path['customer']:
lg.warn('trying to delete file stored for another cusomer')
continue
# TODO: add validation of customerGlobID
# TODO: process requests from another customer
filename = make_valid_filename(newpacket.OwnerID, glob_path)
if not filename:
lg.warn("got empty filename, bad customer or wrong packetID?")
p2p_service.SendFail(newpacket,
'not a customer, or file not found')
return False
if os.path.isfile(filename):
try:
os.remove(filename)
filescount += 1
except:
lg.exc()
elif os.path.isdir(filename):
try:
bpio._dir_remove(filename)
dirscount += 1
except:
lg.exc()
else:
lg.warn("path not found %s" % filename)
# if self.publish_event_supplier_file_modified:
# events.send('supplier-file-modified', data=dict(
# action='delete',
# glob_path=glob_path['path'],
# owner_id=newpacket.OwnerID,
# ))
if _Debug:
lg.dbg(
_DebugLevel,
"from [%s] with %d IDs, %d files and %d folders were removed" %
(newpacket.OwnerID, len(ids), filescount, dirscount))
p2p_service.SendAck(newpacket)
return True
def load_suppliers(path=None, customer_idurl=None, all_customers=False):
"""
Load suppliers list from disk.
"""
if all_customers:
for customer_id in os.listdir(settings.SuppliersDir()):
if not global_id.IsValidGlobalUser(customer_id):
lg.warn('invalid customer record %s found in %s' %
(customer_id, settings.SuppliersDir()))
continue
path = os.path.join(settings.SuppliersDir(), customer_id,
'supplierids')
lst = bpio._read_list(path)
if lst is None:
lst = list()
set_suppliers(
lst, customer_idurl=global_id.GlobalUserToIDURL(customer_id))
lg.out(
4, 'contactsdb.load_suppliers %d items from %s' %
(len(lst), path))
return True
if path is None:
if customer_idurl is None:
path = settings.SupplierIDsFilename()
else:
path = os.path.join(settings.SuppliersDir(),
global_id.UrlToGlobalID(customer_idurl),
'supplierids')
lst = bpio._read_list(path)
if lst is None:
lst = list()
set_suppliers(lst)
lg.out(4, 'contactsdb.load_suppliers %d items from %s' % (len(lst), path))
return True
def WriteIndex(filepath=None, encoding='utf-8'):
"""
Write index data base to the local file .bitdust/metadata/index.
"""
global _LoadingFlag
if _LoadingFlag:
return
if filepath is None:
filepath = settings.BackupIndexFilePath()
json_data = {}
# json_data = backup_fs.Serialize(to_json=True, encoding=encoding)
for customer_idurl in backup_fs.known_customers():
customer_id = global_id.UrlToGlobalID(customer_idurl)
json_data[customer_id] = backup_fs.Serialize(
iterID=backup_fs.fsID(customer_idurl),
to_json=True,
encoding=encoding,
)
src = '%d\n' % revision()
src += json.dumps(json_data,
indent=1,
separators=(',', ':'),
encoding=encoding)
if _Debug:
import pprint
lg.out(_DebugLevel, pprint.pformat(json_data))
return bpio.WriteTextFile(filepath, src)
def save_suppliers(path=None, customer_idurl=None):
"""
Write current suppliers list on the disk, ``path`` is a file path to save.
"""
if not customer_idurl:
customer_idurl = my_id.getLocalID()
customer_idurl = strng.to_bin(customer_idurl.strip())
customer_id = global_id.UrlToGlobalID(customer_idurl)
if path is None:
path = os.path.join(
settings.SuppliersDir(),
customer_id,
'supplierids',
)
lst = suppliers(customer_idurl=customer_idurl)
lst = list(map(strng.to_text, lst))
if not os.path.exists(os.path.dirname(path)):
bpio._dirs_make(os.path.dirname(path))
bpio._write_list(path, lst)
if _Debug:
lg.out(
_DebugLevel, 'contactsdb.save_suppliers for customer [%s]:\n%r' % (
customer_id,
lst,
))
return True
def SendFiles(
idurl,
raw_list_files_info,
packet_id=None,
callbacks={},
timeout=10,
):
"""
Sending information about known files stored locally for given customer (if you are supplier).
You can also send a list of your files to another user if you wish to grand access.
This will not send any personal data : only file names, ids, versions, etc.
So pass list of files in encrypted form in the `payload` or leave it empty.
"""
MyID = my_id.getLocalID()
if not packet_id:
packet_id = "%s:%s" % (global_id.UrlToGlobalID(idurl),
packetid.UniqueID())
if _Debug:
lg.out(
_DebugLevel, 'p2p_service.SendFiles %d bytes in packetID=%s' %
(len(raw_list_files_info), packet_id))
lg.out(_DebugLevel, ' to remoteID=%s' % idurl)
newpacket = signed.Packet(
Command=commands.Files(),
OwnerID=MyID,
CreatorID=MyID,
PacketID=packet_id,
Payload=raw_list_files_info,
RemoteID=idurl,
)
result = gateway.outbox(newpacket,
callbacks=callbacks,
response_timeout=timeout)
return result
def doRequestService(self, arg):
"""
Action method.
"""
service_info = {
'needed_bytes': self.needed_bytes,
'customer_id': global_id.UrlToGlobalID(self.customer_idurl),
}
my_customer_key_id = my_id.getGlobalID(key_alias='customer')
if my_keys.is_key_registered(my_customer_key_id):
service_info['customer_public_key'] = my_keys.get_key_info(
key_id=my_customer_key_id,
include_private=False,
)
if self.key_id:
service_info['key_id'] = self.key_id
if self.customer_idurl == my_id.getLocalIDURL():
service_info['ecc_map'] = eccmap.Current().name
request = p2p_service.SendRequestService(
remote_idurl=self.supplier_idurl,
service_name='service_supplier',
json_payload=service_info,
callbacks={
commands.Ack(): self._supplier_acked,
commands.Fail(): self._supplier_failed,
},
)
self.request_packet_id = request.PacketID
def doReportFailed(self, *args, **kwargs):
"""
Action method.
"""
lg.warn('share key [%s] with %s FAILED: %s' % (self.key_id, self.remote_idurl, args, ))
reason = 'share key failed with unknown reason'
if args and args[0]:
reason = args[0]
else:
if self.remote_identity is None:
reason='remote id caching failed',
else:
if self.ping_response is None:
reason='remote node not responding',
else:
if self.suppliers_responses:
reason = 'connection timeout with my suppliers'
events.send('private-key-share-failed', dict(
global_id=global_id.UrlToGlobalID(self.remote_idurl),
remote_idurl=self.remote_idurl,
key_id=self.key_id,
reason=reason,
))
if self.result_defer:
self.result_defer.errback(Exception(reason))
def load_suppliers(path=None, customer_idurl=None, all_customers=False):
"""
Load suppliers list from disk.
"""
if all_customers:
for customer_id in os.listdir(settings.SuppliersDir()):
if not global_id.IsValidGlobalUser(customer_id):
lg.warn('invalid customer record %s found in %s' % (customer_id, settings.SuppliersDir()))
continue
path = os.path.join(settings.SuppliersDir(), customer_id, 'supplierids')
lst = bpio._read_list(path)
if lst is None:
lg.warn('did not found suppliers ids at %s' % path)
continue
lst = list(map(strng.to_bin, lst))
set_suppliers(lst, customer_idurl=global_id.GlobalUserToIDURL(customer_id))
lg.out(4, 'contactsdb.load_suppliers %d items from %s' % (len(lst), path))
return True
if not customer_idurl:
customer_idurl = my_id.getLocalID()
customer_idurl = strng.to_bin(customer_idurl.strip())
if path is None:
path = os.path.join(settings.SuppliersDir(), global_id.UrlToGlobalID(customer_idurl), 'supplierids')
lst = bpio._read_list(path)
if lst is None:
lst = list()
lst = list(map(strng.to_bin, lst))
set_suppliers(lst)
lg.out(4, 'contactsdb.load_suppliers %d items from %s' % (len(lst), path))
return True
def doReportRetry(self, event, *args, **kwargs):
"""
Action method.
"""
if _PacketLogFileEnabled:
label = event.upper().replace('-', ' ')
fail_info = args[0]
lg.out(
0,
'\033[0;49;36m%s %s(%s) from %s to %s %s\033[0m' %
(label, fail_info['command'], fail_info['packet_id'],
global_id.UrlToGlobalID(fail_info['from']),
global_id.UrlToGlobalID(fail_info['to']), fail_info['error']),
log_name='packet',
showtime=True,
)
def doRequestService(self, *args, **kwargs):
"""
Action method.
"""
service_info = {
'needed_bytes': self.needed_bytes,
'customer_id': global_id.UrlToGlobalID(self.customer_idurl),
}
my_customer_key_id = my_id.getGlobalID(key_alias='customer')
if my_keys.is_key_registered(my_customer_key_id):
service_info['customer_public_key'] = my_keys.get_key_info(
key_id=my_customer_key_id,
include_private=False,
)
if self.key_id:
service_info['key_id'] = self.key_id
self._last_known_ecc_map = kwargs.get('ecc_map')
if self._last_known_ecc_map is not None:
service_info['ecc_map'] = self._last_known_ecc_map
self._last_known_family_position = kwargs.get('family_position')
if self._last_known_family_position is not None:
service_info['position'] = self._last_known_family_position
self._last_known_family_snapshot = kwargs.get('family_snapshot')
if self._last_known_family_snapshot is not None:
service_info['family_snapshot'] = self._last_known_family_snapshot
request = p2p_service.SendRequestService(
remote_idurl=self.supplier_idurl,
service_name='service_supplier',
json_payload=service_info,
callbacks={
commands.Ack(): self._supplier_acked,
commands.Fail(): self._supplier_failed,
},
)
self.request_packet_id = request.PacketID
def populate_messages(recipient_id=None,
sender_id=None,
message_types=[],
offset=0,
limit=100):
if recipient_id:
if not recipient_id.count('@'):
from contacts import contactsdb
recipient_idurl = contactsdb.find_correspondent_by_nickname(
recipient_id)
if not recipient_idurl:
lg.err('recipient %r was not found' % recipient_id)
return
recipient_id = global_id.UrlToGlobalID(recipient_idurl)
recipient_glob_id = global_id.ParseGlobalID(recipient_id)
if not recipient_glob_id['idurl']:
lg.err('wrong recipient_id')
return
recipient_id = global_id.MakeGlobalID(**recipient_glob_id)
if not my_keys.is_valid_key_id(recipient_id):
lg.err('invalid recipient_id: %s' % recipient_id)
return
if sender_id:
sender_local_key_id = my_keys.get_local_key_id(sender_id)
if sender_local_key_id is None:
return
if recipient_id:
recipient_local_key_id = my_keys.get_local_key_id(recipient_id)
if recipient_local_key_id is None:
lg.warn('recipient %r local key id was not registered' %
recipient_id)
return
for row in query_messages(
sender_id=sender_id,
recipient_id=recipient_id,
bidirectional=False,
message_types=message_types,
offset=offset,
limit=limit,
raw_results=True,
):
conversation_id = get_conversation_id(row[0], row[2], int(row[5]))
if conversation_id is None:
continue
snap_id = '{}/{}'.format(conversation_id, row[7])
listeners.push_snapshot('message',
snap_id=snap_id,
created=row[6],
data=build_json_message(
sender=row[1],
recipient=row[3],
direction='in' if row[4] == 0 else 'out',
conversation_id=conversation_id,
message_type=MESSAGE_TYPE_CODES.get(
int(row[5]), 'private_message'),
message_time=row[6],
message_id=row[7],
data=json.loads(row[8]),
))
def _on_delete_file(self, newpacket):
import os
from logs import lg
from system import bpio
from lib import strng
from userid import global_id
from p2p import p2p_service
from main import events
if not newpacket.Payload:
ids = [newpacket.PacketID, ]
else:
ids = strng.to_text(newpacket.Payload).split('\n')
filescount = 0
dirscount = 0
lg.warn('going to erase files: %s' % ids)
customer_id = global_id.UrlToGlobalID(newpacket.OwnerID)
for pcktID in ids:
glob_path = global_id.ParseGlobalID(pcktID)
if not glob_path['customer']:
glob_path = global_id.ParseGlobalID(customer_id + ':' + pcktID)
if not glob_path['path']:
lg.err("got incorrect PacketID")
p2p_service.SendFail(newpacket, 'incorrect path')
return False
if customer_id != glob_path['customer']:
lg.warn('trying to delete file stored for another cusomer')
continue
# TODO: add validation of customerGlobID
# TODO: process requests from another customer
filename = self._do_make_valid_filename(newpacket.OwnerID, glob_path)
if not filename:
lg.warn("got empty filename, bad customer or wrong packetID?")
p2p_service.SendFail(newpacket, 'not a customer, or file not found')
return False
if os.path.isfile(filename):
try:
os.remove(filename)
filescount += 1
except:
lg.exc()
elif os.path.isdir(filename):
try:
bpio._dir_remove(filename)
dirscount += 1
except:
lg.exc()
else:
lg.warn("path not found %s" % filename)
if self.publish_event_supplier_file_modified:
events.send('supplier-file-modified', data=dict(
action='delete',
glob_path=glob_path['path'],
owner_id=newpacket.OwnerID,
))
lg.out(self.debug_level, "service_supplier._on_delete_file from [%s] with %d IDs, %d files and %d folders were removed" % (
newpacket.OwnerID, len(ids), filescount, dirscount))
p2p_service.SendAck(newpacket)
return True
def doStartListening(self, *args, **kwargs):
"""
Action method.
"""
try:
_, info = args[0]
self.router_proto_host = (info.proto, info.host)
except:
try:
s = config.conf().getString('services/proxy-transport/current-router').strip()
_, router_proto, router_host = s.split(' ')
self.router_proto_host = (router_proto, strng.to_bin(router_host), )
except:
lg.exc()
self.router_identity = identitycache.FromCache(self.router_idurl)
config.conf().setString('services/proxy-transport/current-router', '%s %s %s' % (
strng.to_text(self.router_idurl),
strng.to_text(self.router_proto_host[0]),
strng.to_text(self.router_proto_host[1]),
))
current_identity = my_id.getLocalIdentity().serialize()
previous_identity = ReadMyOriginalIdentitySource()
if previous_identity:
lg.warn('my original identity is not empty, SKIP overwriting')
lg.out(2, '\nPREVIOUS ORIGINAL IDENTITY:\n%s\n' % current_identity)
else:
WriteMyOriginalIdentitySource(current_identity)
lg.warn('current identity was stored as my-original-identity')
self.request_service_packet_id = []
callback.insert_inbox_callback(0, self._on_inbox_packet_received)
if contact_status.isKnown(self.router_idurl):
contact_status.A(self.router_idurl).addStateChangedCallback(
self._on_router_contact_status_connected, newstate='CONNECTED')
contact_status.A(self.router_idurl).addStateChangedCallback(
self._on_router_contact_status_offline, newstate='OFFLINE')
active_router_sessions = gateway.find_active_session(info.proto, info.host)
if active_router_sessions:
self.router_connection_info = {
'id': active_router_sessions[0].id,
'index': active_router_sessions[0].index,
'proto': info.proto,
'host': info.host,
'idurl': self.router_idurl,
'global_id': global_id.UrlToGlobalID(self.router_idurl),
}
active_router_session_machine = automat.objects().get(self.router_connection_info['index'], None)
if active_router_session_machine:
active_router_session_machine.addStateChangedCallback(
self._on_router_session_disconnected, oldstate='CONNECTED')
lg.info('connected to proxy router and set active session: %s' % self.router_connection_info)
else:
lg.err('not found proxy router session state machine: %s' % self.router_connection_info['index'])
else:
lg.err('active connection with proxy router at %s:%s was not found' % (info.proto, info.host, ))
if _Debug:
lg.out(2, 'proxy_receiver.doStartListening !!!!!!! router: %s at %s://%s' % (
self.router_idurl, self.router_proto_host[0], self.router_proto_host[1]))
def save_suppliers(path=None, customer_idurl=None):
"""
Write current suppliers list on the disk, ``path`` is a file path to save.
"""
if path is None:
path = settings.SupplierIDsFilename()
if customer_idurl is not None:
path += ('_%s' % global_id.UrlToGlobalID(customer_idurl))
bpio._write_list(path, suppliers())
def getGlobalID(key_alias=None):
"""
Return my global user id - according to my current IDURL.
"""
from userid import global_id
glob_id = global_id.UrlToGlobalID(getLocalID())
if key_alias:
glob_id = '{}${}'.format(key_alias, glob_id)
return glob_id
def doSendHisFiles(self, arg):
"""
Action method.
"""
packet_id = '%s:%s' % (
global_id.UrlToGlobalID(self.customer_idurl),
packetid.UniqueID(),
)
list_files.send(self.customer_idurl, packet_id,
settings.ListFilesFormat())
def doReportDone(self, *args, **kwargs):
"""
Action method.
"""
lg.info('share key [%s] with %r finished with SUCCESS !!!!!' % (self.key_id, self.remote_idurl, ))
events.send('private-key-shared', dict(
global_id=global_id.UrlToGlobalID(self.remote_idurl),
remote_idurl=self.remote_idurl,
key_id=self.key_id,
))
if self.result_defer:
self.result_defer.callback(True)
def doReportDone(self, *args, **kwargs):
"""
Action method.
"""
lg.info('share group key [%s] with %r finished with success' % (self.group_key_id, self.remote_idurl, ))
events.send('group-key-shared', data=dict(
global_id=global_id.UrlToGlobalID(self.remote_idurl),
remote_idurl=self.remote_idurl,
group_key_id=self.group_key_id,
))
if self.result_defer:
self.result_defer.callback(True)
def doReportDone(self, arg):
"""
Action method.
"""
events.send(
'private-key-shared',
dict(
global_id=global_id.UrlToGlobalID(self.remote_idurl),
remote_idurl=self.remote_idurl,
key_id=self.key_id,
))
if self.result_defer:
self.result_defer.callback(True)
def doReportTimeOut(self, *args, **kwargs):
"""
Action method.
"""
if None in self.callbacks:
for cb in self.callbacks[None]:
cb(self)
if _Debug:
lg.out(4,
'\033[2;49;90mTIMEOUT %s(%s) sending to %s\033[0m' %
(self.outpacket.Command, self.outpacket.PacketID,
global_id.UrlToGlobalID(self.remote_idurl)),
log_name='packet')
def _do_request_supplier_service(self, ecc_map, family_position,
family_snapshot):
if _Debug:
lg.args(_DebugLevel,
supplier_idurl=self.supplier_idurl,
ecc_map=ecc_map,
family_position=family_position,
family_snapshot=family_snapshot)
if not self.supplier_idurl:
lg.warn(
'supplier idurl is empty, SKIP sending supplier_service request'
)
return
service_info = {
'needed_bytes': self.needed_bytes,
'customer_id': global_id.UrlToGlobalID(self.customer_idurl),
}
my_customer_key_id = my_id.getGlobalID(key_alias='customer')
if my_keys.is_key_registered(my_customer_key_id):
service_info['customer_public_key'] = my_keys.get_key_info(
key_id=my_customer_key_id,
include_private=False,
include_signature=True,
generate_signature=True,
)
else:
lg.warn('my own customer key is not registered: %r' %
my_customer_key_id)
if self.key_id:
service_info['key_id'] = self.key_id
self._last_known_ecc_map = ecc_map
if self._last_known_ecc_map is not None:
service_info['ecc_map'] = self._last_known_ecc_map
self._last_known_family_position = family_position
if self._last_known_family_position is not None:
service_info['position'] = self._last_known_family_position
self._last_known_family_snapshot = family_snapshot
if self._last_known_family_snapshot is not None:
service_info['family_snapshot'] = id_url.to_bin_list(
self._last_known_family_snapshot)
request = p2p_service.SendRequestService(
remote_idurl=self.supplier_idurl,
service_name='service_supplier',
json_payload=service_info,
callbacks={
commands.Ack(): self._supplier_service_acked,
commands.Fail(): self._supplier_service_failed,
},
)
self.request_packet_id = request.PacketID
def _on_identity_url_changed(self, evt):
from twisted.internet import reactor # @UnresolvedImport
from logs import lg
from userid import id_url
from userid import global_id
from p2p import online_status
for idurl, inst in online_status.online_statuses().items():
if idurl == id_url.field(evt.data['old_idurl']):
idurl.refresh(replace_original=True)
inst.idurl.refresh(replace_original=True)
inst.name = 'online_%s' % global_id.UrlToGlobalID(idurl)
inst.automat('shook-up-hands')
reactor.callLater(0, inst.automat, 'ping-now') # @UndefinedVariable
lg.info('found %r with rotated identity and refreshed: %r' % (inst, idurl, ))
def save_suppliers(path=None, customer_idurl=None):
"""
Write current suppliers list on the disk, ``path`` is a file path to save.
"""
if not customer_idurl:
customer_idurl = my_id.getLocalID()
if path is None:
path = os.path.join(
settings.SuppliersDir(),
global_id.UrlToGlobalID(customer_idurl),
'supplierids',
)
bpio._write_list(path, suppliers(customer_idurl=customer_idurl))
return True
def _on_request_service_ack(self, response, info):
self.router_connection_info = None
if response.PacketID not in self.request_service_packet_id:
lg.warn('wrong PacketID in response: %s, but outgoing was : %s' % (
response.PacketID, str(self.request_service_packet_id)))
self.automat('service-refused', (response, info))
return
if response.PacketID in self.request_service_packet_id:
self.request_service_packet_id.remove(response.PacketID)
else:
lg.warn('%s was not found in pending requests: %s' % (response.PacketID, self.request_service_packet_id))
if _Debug:
lg.out(_DebugLevel, 'proxy_receiver._on_request_service_ack : %s' % str(response.Payload))
if self.router_idurl != response.CreatorID:
lg.err('received unexpected response from another node: %r ~ %r' % (self.router_idurl, response.CreatorID, ))
self.automat('service-refused', (response, info))
return
service_ack_info = strng.to_text(response.Payload)
if service_ack_info.startswith('rejected'):
self.automat('service-refused', (response, info))
return
active_router_sessions = gateway.find_active_session(info.proto, host=info.host)
if not active_router_sessions:
active_router_sessions = gateway.find_active_session(info.proto, idurl=id_url.to_bin(response.CreatorID))
if not active_router_sessions:
lg.err('active connection with proxy router at %s:%s was not found' % (info.proto, info.host, ))
if _Debug:
lg.args(_DebugLevel, router_idurl=self.router_idurl, ack_packet=info, active_sessions=gateway.list_active_sessions(info.proto))
self.automat('service-refused', (response, info))
return
self.router_connection_info = {
'id': active_router_sessions[0].id,
'index': active_router_sessions[0].index,
'repr': repr(active_router_sessions[0]),
'proto': info.proto,
'host': info.host,
'idurl': self.router_idurl,
'global_id': global_id.UrlToGlobalID(self.router_idurl),
}
active_router_session_machine = automat.by_index(self.router_connection_info['index'])
if active_router_session_machine is None:
lg.err('did not found proxy router session state machine instance: %s' % self.router_connection_info)
self.router_connection_info = None
if _Debug:
lg.args(_DebugLevel, automats=automat.objects())
self.automat('service-refused', (response, info))
return
lg.info('found active session for proxy router: %s' % active_router_session_machine)
self.automat('service-accepted', (response, info, active_router_session_machine))
def load_suppliers(path=None, customer_idurl=None, all_customers=False):
"""
Load suppliers list from disk.
"""
if all_customers:
list_local_customers = list(os.listdir(settings.SuppliersDir()))
if _Debug:
lg.out(_DebugLevel, 'contactsdb.load_suppliers %d known customers' % len(list_local_customers))
for customer_id in list_local_customers:
if not global_id.IsValidGlobalUser(customer_id):
lg.warn('invalid customer record %s found in %s' % (customer_id, settings.SuppliersDir()))
continue
path = os.path.join(settings.SuppliersDir(), customer_id, 'supplierids')
lst = bpio._read_list(path)
if lst is None:
lg.warn('did not found suppliers ids at %s' % path)
continue
one_customer_idurl = global_id.GlobalUserToIDURL(customer_id)
if not id_url.is_cached(one_customer_idurl):
lg.warn('customer identity %r not cached yet' % one_customer_idurl)
continue
if not one_customer_idurl.is_latest():
latest_customer_path = os.path.join(settings.SuppliersDir(), one_customer_idurl.to_id())
old_customer_path = os.path.join(settings.SuppliersDir(), customer_id)
if not os.path.exists(latest_customer_path):
os.rename(old_customer_path, latest_customer_path)
lg.info('detected and processed idurl rotate when loading suppliers for customer : %r -> %r' % (customer_id, one_customer_idurl.to_id()))
else:
bpio._dir_remove(old_customer_path)
lg.warn('found old customer dir %r and removed' % old_customer_path)
continue
lst = list(map(lambda i: i if id_url.is_cached(i) else b'', lst))
set_suppliers(lst, customer_idurl=one_customer_idurl)
if _Debug:
lg.out(_DebugLevel, ' loaded %d known suppliers for customer %r' % (len(lst), one_customer_idurl))
return True
if not customer_idurl:
customer_idurl = my_id.getLocalID()
customer_idurl = id_url.field(customer_idurl)
if path is None:
path = os.path.join(settings.SuppliersDir(), global_id.UrlToGlobalID(customer_idurl), 'supplierids')
lst = bpio._read_list(path)
if lst is None:
lst = list()
lst = list(map(lambda i: i if id_url.is_cached(i) else b'', lst))
set_suppliers(lst, customer_idurl=customer_idurl)
if _Debug:
lg.out(_DebugLevel, 'contactsdb.load_suppliers %d items from %s' % (len(lst), path))
return True
def doReportDoneNoAck(self, *args, **kwargs):
"""
Action method.
"""
callback.run_queue_item_status_callbacks(self, 'finished',
'unanswered')
if _Debug:
lg.out(
2,
'\033[0;49;95mOUT %s(%s) with %s bytes to %s TID:%r\033[0m' %
(self.outpacket.Command, self.outpacket.PacketID, self.filesize
or '?', global_id.UrlToGlobalID(
self.remote_idurl), [i.transfer_id
for i in self.results]),
log_name='packet')
def getGlobalID(key_alias=None):
"""
Returns my global user id - according to my current IDURL.
"""
global _LocalID
if not key_alias and _LocalID is not None:
return _LocalID
if key_alias == 'master' and _LocalID is not None:
return strng.to_text('{}${}'.format(key_alias, _LocalID))
from userid import global_id
glob_id = global_id.UrlToGlobalID(getIDURL())
if not glob_id:
return glob_id
if key_alias:
glob_id = strng.to_text('{}${}'.format(key_alias, glob_id))
return glob_id
def __init__(self, customer_idurl, new_data=None, publish=False,
limit_lookups=100, max_misses_in_row=3, prefix='customer_supplier'):
self.customer_idurl = customer_idurl
self.customer_id = global_id.UrlToGlobalID(self.customer_idurl)
self._result_defer = Deferred()
self._new_data = new_data
self._publish = publish
self._limit_lookups = limit_lookups
self._index = 0
self._last_success_index = -1
self._last_missed_index = -1
self._max_misses_in_row = max_misses_in_row
self._prefix = prefix
self._misses_in_row = 0
self._missed = 0
self._result = {}
self._meta = {}
def doReportFailed(self, event, *args, **kwargs):
"""
Action method.
"""
lg.warn('share group key [%s] with %s failed: %s' % (self.group_key_id, self.remote_idurl, args, ))
reason = 'group key transfer failed with unknown reason'
if args and args[0]:
reason = args[0]
else:
if event.count('timer-'):
reason = 'group key transfer failed because of network connection timeout'
events.send('group-key-share-failed', data=dict(
global_id=global_id.UrlToGlobalID(self.remote_idurl),
remote_idurl=self.remote_idurl,
group_key_id=self.group_key_id,
reason=reason,
))
if self.result_defer:
self.result_defer.errback(Exception(reason))
