def generate_key(key_id, label='', key_size=4096, keys_folder=None):
"""
"""
if key_id in known_keys():
lg.warn('key "%s" already exists' % key_id)
return None
if not label:
label = 'key%s' % utime.make_timestamp()
if _Debug:
lg.out(
_DebugLevel, 'my_keys.generate_key "%s" of %d bits, label=%r' %
(key_id, key_size, label))
key_object = rsa_key.RSAKey()
key_object.generate(key_size)
key_object.label = label
known_keys()[key_id] = key_object
if _Debug:
lg.out(_DebugLevel, ' key %s generated' % key_id)
if not keys_folder:
keys_folder = settings.KeyStoreDir()
save_key(key_id, keys_folder=keys_folder)
events.send('key-generated',
data=dict(
key_id=key_id,
label=label,
key_size=key_size,
))
return key_object
def doRemoveSuppliers(self, *args, **kwargs):
"""
Action method.
"""
current_suppliers = contactsdb.suppliers()
desired_suppliers = settings.getSuppliersNumberDesired()
if len(current_suppliers) < desired_suppliers:
lg.warn('must have more suppliers %d<%d' % (
len(current_suppliers), desired_suppliers))
removed_suppliers = []
for supplier_idurl in self.dismiss_list:
if supplier_idurl not in current_suppliers:
lg.warn('%s not a supplier' % supplier_idurl)
continue
pos = current_suppliers.index(supplier_idurl)
# current_suppliers.remove(supplier_idurl)
current_suppliers[pos] = ''
removed_suppliers.append((pos, supplier_idurl,))
misc.writeSupplierData(
supplier_idurl,
'disconnected',
time.strftime('%d-%m-%Y %H:%M:%S'),
my_id.getLocalID(),
)
current_suppliers = current_suppliers[:desired_suppliers]
contactsdb.update_suppliers(current_suppliers)
contactsdb.save_suppliers()
from main import control
control.on_suppliers_changed(current_suppliers)
for position, supplier_idurl in removed_suppliers:
events.send('supplier-modified', dict(
new_idurl=None, old_idurl=supplier_idurl, position=position,
))
lg.out(2, '!!!!!!!!!!! REMOVE SUPPLIERS : %d' % len(self.dismiss_list))
def doDestroyMe(self, *args, **kwargs):
"""
Remove all references to the state machine object to destroy it.
"""
events.send('outbox-packet-finished',
data=dict(
description=self.description,
packet_id=self.outpacket.PacketID,
command=self.outpacket.Command,
creator_id=self.outpacket.CreatorID,
date=self.outpacket.Date,
size=len(self.outpacket.Payload),
remote_id=self.outpacket.RemoteID,
))
if self not in self.outpacket.Packets:
lg.warn('packet_out not connected to the packet')
else:
self.outpacket.Packets.remove(self)
self.outpacket = None
self.remote_identity = None
if self.caching_deferred and not self.caching_deferred.called:
self.caching_deferred.cancel()
self.caching_deferred = None
self.callbacks.clear()
queue().remove(self)
self.destroy()
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 __init__(self, BackupID, OutputFile, KeyID=None): # OutputFileName
self.CreatorID = my_id.getLocalID()
self.BackupID = BackupID
_parts = packetid.SplitBackupID(self.BackupID)
self.CustomerGlobalID = _parts[0]
self.CustomerIDURL = global_id.GlobalUserToIDURL(self.CustomerGlobalID)
self.PathID = _parts[1]
self.Version = _parts[2]
self.File = OutputFile
self.KeyID = KeyID
# is current active block - so when add 1 we get to first, which is 0
self.BlockNumber = -1
self.BytesWritten = 0
self.OnHandData = []
self.OnHandParity = []
self.AbortState = False
self.Done = False
self.EccMap = eccmap.Current()
self.Started = time.time()
self.LastAction = time.time()
self.InboxPacketsQueue = []
self.InboxQueueWorker = None
self.RequestFails = []
self.InboxQueueDelay = 1
# For anyone who wants to know when we finish
self.MyDeferred = Deferred()
self.packetInCallback = None
self.blockRestoredCallback = None
automat.Automat.__init__(self, 'restore_%s' % self.BackupID,
'AT_STARTUP', _DebugLevel, _Debug)
events.send('restore-started', dict(backup_id=self.BackupID))
def eraseLocalIdentity(do_backup=True):
if do_backup:
if os.path.isfile(settings.LocalIdentityFilename()):
current_identity_xmlsrc = local_fs.ReadBinaryFile(settings.LocalIdentityFilename())
if current_identity_xmlsrc:
fd, fname = tempfile.mkstemp(prefix='localidentity_', dir=settings.MetaDataDir())
os.write(fd, current_identity_xmlsrc)
os.close(fd)
lg.info('created backup copy of my local identity in the file : %r' % fname)
filename = bpio.portablePath(settings.LocalIdentityFilename())
if not os.path.exists(filename):
if _Debug:
lg.out(_DebugLevel, "my_id.eraseLocalIdentity SKIP file %s not exist" % filename)
return True
if not os.path.isfile(filename):
if _Debug:
lg.out(_DebugLevel, "my_id.eraseLocalIdentity ERROR path %s is not a file" % filename)
return False
try:
os.remove(filename)
except:
lg.exc()
return False
events.send('local-identity-erased', data=dict())
if _Debug:
lg.out(_DebugLevel, "my_id.eraseLocalIdentity file %s was deleted" % filename)
return True
def rename_key(current_key_id, new_key_id, keys_folder=None):
"""
"""
if not keys_folder:
keys_folder = settings.KeyStoreDir()
if current_key_id not in known_keys():
lg.warn('key %s is not found' % current_key_id)
return False
if key_obj(current_key_id).isPublic():
current_key_filepath = os.path.join(keys_folder, current_key_id + '.public')
new_key_filepath = os.path.join(keys_folder, new_key_id + '.public')
is_private = False
else:
current_key_filepath = os.path.join(keys_folder, current_key_id + '.private')
new_key_filepath = os.path.join(keys_folder, new_key_id + '.private')
is_private = True
try:
os.rename(current_key_filepath, new_key_filepath)
except:
lg.exc()
return False
key_object = known_keys().pop(current_key_id)
known_keys()[new_key_id] = key_object
gc.collect()
if _Debug:
lg.out(_DebugLevel, 'my_keys.rename_key key %s renamed to %s' % (current_key_id, new_key_id, ))
lg.out(_DebugLevel, ' file %s renamed to %s' % (current_key_filepath, new_key_filepath, ))
events.send('key-renamed', data=dict(old_key_id=current_key_id, new_key_id=new_key_id, is_private=is_private))
return True
def doReportDisconnected(self, *args, **kwargs):
"""
Action method.
"""
events.send('share-disconnected', dict(self.to_json()))
if self.result_defer:
self.result_defer.errback(Exception('disconnected'))
def state_changed(self, oldstate, newstate, event, *args, **kwargs):
"""
Method to catch the moment when index_synchronizer() state were
changed.
"""
if newstate == 'IN_SYNC!':
if A().last_time_in_sync > 0 and time.time() - A(
).last_time_in_sync < 30:
if _Debug:
lg.dbg(
_DebugLevel,
'backup index already synchronized %r seconds ago' %
(time.time() - A().last_time_in_sync))
else:
if _Debug:
lg.dbg(
_DebugLevel,
'backup index just synchronized, sending "my-backup-index-synchronized" event'
)
events.send('my-backup-index-synchronized', data={})
self.last_time_in_sync = time.time()
if self.PushAgain:
reactor.callLater(0, self.automat,
'instant') # @UndefinedVariable
if newstate == 'NO_INFO' and oldstate in [
'REQUEST?',
'SENDING',
]:
events.send('my-backup-index-out-of-sync', data={})
if newstate == 'NO_INFO':
self.last_time_in_sync = -1
def register_key(key_id, key_object_or_string, label='', keys_folder=None):
"""
"""
if key_id in known_keys():
lg.warn('key %s already exists' % key_id)
return None
if not label:
label = 'key%s' % utime.make_timestamp()
if strng.is_string(key_object_or_string):
if _Debug:
lg.out(_DebugLevel, 'my_keys.register_key %s from %d bytes openssh_input_string' % (
key_id, len(key_object_or_string)))
key_object = unserialize_key_to_object(key_object_or_string)
if not key_object:
lg.warn('invalid openssh string, unserialize_key_to_object() failed')
return None
else:
if _Debug:
lg.out(_DebugLevel, 'my_keys.register_key %s from object' % key_id)
key_object = key_object_or_string
known_keys()[key_id] = key_object
if _Debug:
lg.out(_DebugLevel, ' key %s added' % key_id)
if not keys_folder:
keys_folder = settings.KeyStoreDir()
save_key(key_id, keys_folder=keys_folder)
events.send('key-registered', data=dict(key_id=key_id, label=label, key_size=key_object.size(), ))
return key_object
def cancel(self, request, info):
from main import events
from p2p import p2p_service
if not contactsdb.is_customer(request.OwnerID):
lg.warn(
"got packet from %s, but he is not a customer" %
request.OwnerID)
return p2p_service.SendFail(request, 'not a customer')
if accounting.check_create_customers_quotas():
lg.out(6, 'service_supplier.cancel created a new space file')
space_dict = accounting.read_customers_quotas()
if request.OwnerID not in space_dict.keys():
lg.warn(
"got packet from %s, but not found him in space dictionary" %
request.OwnerID)
return p2p_service.SendFail(request, 'not a customer')
try:
free_bytes = int(space_dict['free'])
space_dict['free'] = free_bytes + int(space_dict[request.OwnerID])
except:
lg.exc()
return p2p_service.SendFail(request, 'broken space file')
new_customers = list(contactsdb.customers())
new_customers.remove(request.OwnerID)
contactsdb.update_customers(new_customers)
contactsdb.save_customers()
space_dict.pop(request.OwnerID)
accounting.write_customers_quotas(space_dict)
from supplier import local_tester
reactor.callLater(0, local_tester.TestUpdateCustomers)
lg.out(8, " OLD CUSTOMER: TERMINATED !!!!!!!!!!!!!!")
events.send('existing-customer-terminated', dict(idurl=request.OwnerID))
return p2p_service.SendAck(request, 'accepted')
def start(self):
from logs import lg
from transport import callback
from main import events
from contacts import contactsdb
from storage import accounting
from services import driver
from supplier import customer_space
callback.append_inbox_callback(self._on_inbox_packet_received)
events.add_subscriber(customer_space.on_identity_url_changed, 'identity-url-changed')
events.add_subscriber(customer_space.on_customer_accepted, 'existing-customer-accepted')
events.add_subscriber(customer_space.on_customer_accepted, 'new-customer-accepted')
events.add_subscriber(customer_space.on_customer_terminated, 'existing-customer-denied')
events.add_subscriber(customer_space.on_customer_terminated, 'existing-customer-terminated')
space_dict, _ = accounting.read_customers_quotas()
for customer_idurl in contactsdb.customers():
known_customer_meta_info = contactsdb.get_customer_meta_info(customer_idurl)
events.send('existing-customer-accepted', data=dict(
idurl=customer_idurl,
allocated_bytes=space_dict.get(customer_idurl.to_bin()),
ecc_map=known_customer_meta_info.get('ecc_map'),
position=known_customer_meta_info.get('position'),
))
if driver.is_on('service_entangled_dht'):
self._do_connect_suppliers_dht_layer()
else:
lg.warn('service service_entangled_dht is OFF')
events.add_subscriber(self._on_dht_layer_connected, event_id='dht-layer-connected')
return True
def on_contacts_changed(old_contacts_list, new_contacts_list):
from main import events
events.send('contacts-changed',
data=dict(
old_contacts=old_contacts_list,
new_contacts=new_contacts_list,
))
def doReadAndUnserialize(self, *args, **kwargs):
"""
Action method.
"""
from transport import gateway
self.status, self.bytes_received, self.error_message = args[0]
if _PacketLogFileEnabled:
lg.out(
0,
' \033[2;49;32mRECEIVED %d bytes from %s://%s TID:%s\033[0m'
%
(self.bytes_received, self.proto, self.host, self.transfer_id),
log_name='packet',
showtime=True)
# DO UNSERIALIZE HERE , no exceptions
newpacket = gateway.inbox(self)
if newpacket is None:
if _Debug:
lg.out(
_DebugLevel, '<<< IN <<< !!!NONE!!! [%s] %s from %s %s' % (
self.proto.upper().ljust(5),
self.status.ljust(8),
self.host,
os.path.basename(self.filename),
))
# net_misc.ConnectionFailed(None, proto, 'receiveStatusReport %s' % host)
try:
fd, _ = tmpfile.make('error', extension='.inbox')
data = bpio.ReadBinaryFile(self.filename)
os.write(
fd,
strng.to_bin('from %s:%s %s\n' %
(self.proto, self.host, self.status)))
os.write(fd, data)
os.close(fd)
except:
lg.exc()
if os.path.isfile(self.filename):
try:
os.remove(self.filename)
except:
lg.exc()
self.automat('unserialize-failed', None)
return
self.label = '[%s(%s)]' % (newpacket.Command, newpacket.PacketID)
if _Debug:
lg.out(_DebugLevel,
'packet_in.doReadAndUnserialize: %s' % newpacket)
self.automat('valid-inbox-packet', newpacket)
if False:
events.send('inbox-packet-recevied',
data=dict(
packet_id=newpacket.PacketID,
command=newpacket.Command,
creator_id=newpacket.CreatorID,
date=newpacket.Date,
size=len(newpacket.Payload),
remote_id=newpacket.RemoteID,
))
def cancel(self, json_payload, newpacket, info):
from twisted.internet import reactor # @UnresolvedImport
from logs import lg
from main import events
from p2p import p2p_service
from contacts import contactsdb
from storage import accounting
customer_idurl = newpacket.OwnerID
if not contactsdb.is_customer(customer_idurl):
lg.warn("got packet from %s, but he is not a customer" % customer_idurl)
return p2p_service.SendFail(newpacket, 'not a customer')
if accounting.check_create_customers_quotas():
lg.out(6, 'service_supplier.cancel created a new space file')
space_dict = accounting.read_customers_quotas()
if customer_idurl not in list(space_dict.keys()):
lg.warn("got packet from %s, but not found him in space dictionary" % customer_idurl)
return p2p_service.SendFail(newpacket, 'not a customer')
try:
free_bytes = int(space_dict[b'free'])
space_dict[b'free'] = free_bytes + int(space_dict[customer_idurl])
except:
lg.exc()
return p2p_service.SendFail(newpacket, 'broken space file')
new_customers = list(contactsdb.customers())
new_customers.remove(customer_idurl)
contactsdb.update_customers(new_customers)
contactsdb.remove_customer_meta_info(customer_idurl)
contactsdb.save_customers()
space_dict.pop(customer_idurl)
accounting.write_customers_quotas(space_dict)
from supplier import local_tester
reactor.callLater(0, local_tester.TestUpdateCustomers) # @UndefinedVariable
lg.out(8, " OLD CUSTOMER: TERMINATED !!!!!!!!!!!!!!")
events.send('existing-customer-terminated', dict(idurl=customer_idurl))
return p2p_service.SendAck(newpacket, 'accepted')
def doReportSuccess(self, *args, **kwargs):
"""
Action method.
"""
events.send('share-connected', dict(self.to_json()))
if self.result_defer:
self.result_defer.callback(True)
def erase_key(key_id, keys_folder=None):
"""
"""
if key_id not in known_keys():
lg.warn('key %s is not found' % key_id)
return False
if not keys_folder:
keys_folder = settings.KeyStoreDir()
if key_obj(key_id).isPublic():
key_filepath = os.path.join(keys_folder, key_id + '.public')
is_private = False
else:
key_filepath = os.path.join(keys_folder, key_id + '.private')
is_private = True
try:
os.remove(key_filepath)
except:
lg.exc()
return False
known_keys().pop(key_id)
gc.collect()
if _Debug:
lg.out(_DebugLevel,
' key %s removed, file %s deleted' % (key_id, key_filepath))
events.send('key-erased', data=dict(key_id=key_id, is_private=is_private))
return True
def start(self):
from transport import callback
from main import events
from contacts import contactsdb
from storage import accounting
callback.append_inbox_callback(self._on_inbox_packet_received)
events.add_subscriber(self._on_customer_accepted,
'existing-customer-accepted')
events.add_subscriber(self._on_customer_accepted,
'new-customer-accepted')
events.add_subscriber(self._on_customer_terminated,
'existing-customer-denied')
events.add_subscriber(self._on_customer_terminated,
'existing-customer-terminated')
space_dict = accounting.read_customers_quotas()
for customer_idurl in contactsdb.customers():
known_customer_meta_info = contactsdb.get_customer_meta_info(
customer_idurl)
events.send('existing-customer-accepted',
data=dict(
idurl=customer_idurl,
allocated_bytes=space_dict.get(customer_idurl),
ecc_map=known_customer_meta_info.get('ecc_map'),
position=known_customer_meta_info.get('position'),
))
return True
def RunTask():
"""
Checks current jobs and run a one task if it is possible.
Verifies if it is possible to start a new task,
the maximum number of simultaneously running ``Jobs`` is limited.
"""
if len(tasks()) == 0:
return False
if len(jobs()) >= MAXIMUM_JOBS_STARTED:
return False
from customer import fire_hire
if not fire_hire.IsAllHired():
if _Debug:
lg.out(
_DebugLevel,
'backup_control.RunTask some suppliers not hired yet, retry after 5 sec'
)
reactor.callLater(5, RunTask) # @UndefinedVariable
return False
T = tasks().pop(0)
message = T.run()
if message:
events.send('backup-task-failed',
data=dict(
path_id=T.pathID,
message=message,
))
T.result_defer.errback((T.pathID, message))
else:
# events.send('backup-task-executed', data=dict(path_id=T.pathID, backup_id=T.backupID, ))
T.result_defer.callback((T.backupID, None))
T.destroy(message)
return True
def saveLocalIdentity():
"""
Save identity object from memory into local file.
Do sign the identity than serialize to write to the file.
"""
global _LocalIdentity
if not isLocalIdentityReady():
lg.warn("ERROR local identity not exist!")
return False
if not _LocalIdentity.isCorrect():
lg.warn('local identity is not correct')
return False
_LocalIdentity.sign()
if not _LocalIdentity.Valid():
lg.err('local identity is not valid')
return False
xmlid = _LocalIdentity.serialize(as_text=True)
filename = bpio.portablePath(settings.LocalIdentityFilename())
bpio.WriteTextFile(filename, xmlid)
setTransportOrder(getOrderFromContacts(_LocalIdentity))
events.send('local-identity-written', data=dict(idurl=_LocalIdentity.getIDURL(), filename=filename))
if _Debug:
lg.out(_DebugLevel, "my_id.saveLocalIdentity %d bytes wrote to %s" % (len(xmlid), filename))
return True
def state_changed(self, oldstate, newstate, event, *args, **kwargs):
"""
This method intended to catch the moment when automat's state were
changed.
"""
if newstate in ['CONNECTED', 'DISCONNECTED', 'NO_SERVICE']:
supplierPath = settings.SupplierPath(
self.supplier_idurl, customer_idurl=self.customer_idurl)
if not os.path.isdir(supplierPath):
try:
os.makedirs(supplierPath)
except:
lg.exc()
return
bpio.WriteTextFile(
settings.SupplierServiceFilename(
self.supplier_idurl, customer_idurl=self.customer_idurl),
newstate,
)
if newstate == 'CONNECTED':
if not self._supplier_connected_event_sent:
self._supplier_connected_event_sent = True
events.send('supplier-connected',
data=dict(
supplier_idurl=self.supplier_idurl,
customer_idurl=self.customer_idurl,
needed_bytes=self.needed_bytes,
key_id=self.key_id,
))
if newstate in [
'DISCONNECTED',
'NO_SERVICE',
]:
self._supplier_connected_event_sent = False
def __init__(self, pathID, localPath=None, keyID=None):
self.number = NewTaskNumber() # index number for the task
self.created = time.time()
self.backupID = None
self.pathID = None
self.fullGlobPath = None
self.fullCustomerID = None
self.customerGlobID = None
self.customerIDURL = None
self.remotePath = None
self.keyID = None
self.keyAlias = None
self.result_defer = Deferred()
self.result_defer.addCallback(OnTaskExecutedCallback)
self.result_defer.addErrback(OnTaskFailedCallback)
parts = self.set_path_id(pathID)
self.set_key_id(keyID or my_keys.make_key_id(alias=parts['key_alias'], creator_glob_id=parts['customer']))
self.set_local_path(localPath)
if _Debug:
lg.out(_DebugLevel, 'new Task created: %r' % self)
events.send('backup-task-created', data=dict(
number=self.number,
created=self.created,
backup_id=self.backupID,
key_id=self.keyID,
path_id=self.pathID,
customer_id=self.customerGlobID,
path=self.remotePath,
local_path=self.localPath,
remote_path=self.fullGlobPath,
))
def doReportDisconnected(self, *args, **kwargs):
"""
Action method.
"""
self.dht_lookup_use_cache = False
for packet_id in self.outgoing_list_files_packets_ids:
packetsToCancel = packet_out.search_by_packet_id(packet_id)
for pkt_out in packetsToCancel:
if pkt_out.outpacket.Command == commands.ListFiles():
lg.warn('sending "cancel" to %r from %r' % (
pkt_out,
self,
))
pkt_out.automat('cancel')
events.send('share-disconnected', data=dict(self.to_json()))
if self.result_defer:
self.result_defer.errback(Exception('disconnected'))
for cb_id in list(self.connected_callbacks.keys()):
if cb_id in self.connected_callbacks:
cb = self.connected_callbacks[cb_id]
cb(cb_id, False)
if _Debug:
lg.args(_DebugLevel,
key_id=self.key_id,
ecc_map=self.known_ecc_map)
def state_changed(self, oldstate, newstate, event, *args, **kwargs):
"""
Method to catch the moment when `online_status()` state were changed.
"""
if _Debug:
lg.out(_DebugLevel - 2, '%s : [%s]->[%s]' % (self.name, oldstate, newstate))
if newstate == 'CONNECTED':
lg.info('remote node connected : %s' % self.idurl)
events.send('node-connected', data=dict(
global_id=self.idurl.to_id(),
idurl=self.idurl,
old_state=oldstate,
new_state=newstate,
))
listeners.push_snapshot('online_status', snap_id=self.idurl.to_bin(), data=self.to_json())
if newstate == 'OFFLINE' and oldstate != 'AT_STARTUP':
lg.info('remote node disconnected : %s' % self.idurl)
events.send('node-disconnected', data=dict(
global_id=self.idurl.to_id(),
idurl=self.idurl,
old_state=oldstate,
new_state=newstate,
))
listeners.push_snapshot('online_status', snap_id=self.idurl.to_bin(), data=self.to_json())
if newstate == 'PING?' and oldstate != 'AT_STARTUP':
listeners.push_snapshot('online_status', snap_id=self.idurl.to_bin(), data=self.to_json())
def sign_key(key_id, keys_folder=None):
key_id = latest_key_id(strng.to_text(key_id))
if key_id not in known_keys():
lg.warn('key %s is not found' % key_id)
return False
if not keys_folder:
keys_folder = settings.KeyStoreDir()
key_object = known_keys()[key_id]
signed_key_info = make_key_info(key_object,
key_id=key_id,
include_private=True,
sign_key=True)
key_object.signed = (
signed_key_info['signature'],
signed_key_info['signature_pubkey'],
)
known_keys()[key_id] = key_object
save_key(key_id, keys_folder=keys_folder)
events.send('key-signed',
data=dict(
key_id=key_id,
label=key_object.label,
key_size=key_object.size(),
))
return key_object
def load_key(key_id, keys_folder=None):
global _LatestLocalKeyID
if not is_valid_key_id(key_id):
lg.warn('key is not valid: %r' % key_id)
return False
key_dict = read_key_file(key_id, keys_folder=keys_folder)
try:
key_object = rsa_key.RSAKey()
key_object.fromDict(key_dict)
except:
lg.exc()
return False
if not key_object.isPublic():
if not validate_key(key_object):
lg.warn('validation failed for: %r' % key_id)
return False
known_keys()[key_id] = key_object
if key_dict.get('need_to_convert'):
save_key(key_id, keys_folder=keys_folder)
lg.info('key %r format converted to JSON' % key_id)
else:
if key_object.local_key_id is not None:
if _LatestLocalKeyID < key_object.local_key_id:
_LatestLocalKeyID = key_object.local_key_id
save_latest_local_key_id(keys_folder=keys_folder)
local_keys()[key_object.local_key_id] = key_id
local_keys_index()[
key_object.toPublicString()] = key_object.local_key_id
if _Debug:
lg.out(
_DebugLevel,
'my_keys.load_key %r label=%r is_private=%r local_key_id=%r from %s'
% (
key_id,
key_object.label,
not key_object.isPublic(),
key_object.local_key_id,
keys_folder,
))
else:
lg.warn('for key %r local_key_id was not set' % key_id)
events.send('key-loaded',
data=dict(
key_id=key_id,
label=key_object.label,
key_size=key_object.size(),
))
listeners.push_snapshot('key',
snap_id=key_id,
data=make_key_info(
key_object=key_object,
key_id=key_id,
event='key-loaded',
include_private=False,
include_local_id=True,
include_signature=True,
include_label=True,
))
return True
def on_event(event, argument):
"""
A function that listens to the blockchain and collects addresses from
incoming blocks.
"""
logging.info("EVENT: [{}] with {} bytes".format(event, len(str(argument))))
# reactor.callFromThread(events.send, 'blockchain-{}'.format(event), ) # data=dict(argument=argument))
events.send('blockchain-{}'.format(event), )
def _on_state_change(self, oldstate, newstate, event_string, args):
from main import events
if oldstate != newstate:
events.send('%s-state-change' % self.name, dict(
newstate=newstate,
oldstate=oldstate,
event=event_string,
))
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 _on_user_disconnected(self, evt):
from main import events
from contacts import contactsdb
if contactsdb.is_correspondent(evt.data['idurl']):
events.send('friend-disconnected',
data=dict(
idurl=evt.data['idurl'],
global_id=evt.data['global_id'],
))
