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'], ))