def SendIdentity(remote_idurl, wide=False, timeout=10, callbacks={}): """ """ packet_id = 'identity:%s' % packetid.UniqueID() if _Debug: lg.out( _DebugLevel, "p2p_service.SendIdentity to %s wide=%s packet_id=%r" % ( nameurl.GetName(remote_idurl), wide, packet_id, )) result = signed.Packet( Command=commands.Identity(), OwnerID=my_id.getLocalID(), CreatorID=my_id.getLocalID(), PacketID=packet_id, Payload=my_id.getLocalIdentity().serialize(), RemoteID=remote_idurl, ) gateway.outbox(result, wide=wide, callbacks=callbacks, response_timeout=timeout) return result
def send(customer_idurl, packet_id, format_type): customer_name = nameurl.GetName(customer_idurl) MyID = my_id.getLocalID() RemoteID = customer_idurl PacketID = packet_id if _Debug: lg.out( _DebugLevel, "list_files.send to %s, format is '%s'" % (customer_name, format_type)) custdir = settings.getCustomersFilesDir() ownerdir = os.path.join(custdir, nameurl.UrlFilename(customer_idurl)) if not os.path.isdir(ownerdir): if _Debug: lg.out(_DebugLevel, "list_files.send did not found customer dir: " + ownerdir) src = PackListFiles('', format_type) result = signed.Packet(commands.Files(), MyID, MyID, PacketID, src, RemoteID) gateway.outbox(result) return result plaintext = TreeSummary(ownerdir) if _Debug: lg.out(_DebugLevel + 8, '\n%s' % (plaintext)) src = PackListFiles(plaintext, format_type) result = signed.Packet(commands.Files(), MyID, MyID, PacketID, src, RemoteID) gateway.outbox(result) return result
def SendToID(idurl, ack_handler=None, Payload=None, NeedAck=False, wide=False): """ Create ``packet`` with my Identity file and calls ``transport.gateway.outbox()`` to send it. """ lg.out( 8, "propagate.SendToID [%s] wide=%s" % (nameurl.GetName(idurl), str(wide))) if ack_handler is None: ack_handler = HandleAck thePayload = Payload if thePayload is None: thePayload = my_id.getLocalIdentity().serialize() p = signed.Packet( commands.Identity(), my_id.getLocalID(), # MyID, my_id.getLocalID(), # MyID, 'Identity', # my_id.getLocalID(), #PacketID, thePayload, idurl) # callback.register_interest(AckHandler, p.RemoteID, p.PacketID) gateway.outbox(p, wide, callbacks={ commands.Ack(): ack_handler, commands.Fail(): ack_handler, }) if wide: # this is a ping packet - need to clear old info stats.ErasePeerProtosStates(idurl) stats.EraseMyProtosStates(idurl)
def SendEvent(remote_idurl, event_id, payload=None, producer_id=None, message_id=None, created=None, packet_id=None, wide=False, callbacks={}, response_timeout=5): if packet_id is None: packet_id = packetid.UniqueID() e_json = { 'event_id': event_id, 'payload': payload, } if producer_id and message_id: e_json['producer_id'] = producer_id e_json['message_id'] = message_id if created: e_json['created'] = created e_json_src = serialization.DictToBytes(e_json) if _Debug: lg.out(_DebugLevel, "p2p_service.SendEvent to %s with %d bytes message json data" % ( remote_idurl, len(e_json_src))) outpacket = signed.Packet( Command=commands.Event(), OwnerID=my_id.getLocalID(), CreatorID=my_id.getLocalID(), PacketID=packet_id, Payload=e_json_src, RemoteID=remote_idurl, ) gateway.outbox(outpacket, wide=wide, callbacks=callbacks, response_timeout=response_timeout) return outpacket
def SendListFiles(target_supplier, customer_idurl=None, key_id=None, wide=False, callbacks={}): """ This is used as a request method from your supplier : if you send him a ListFiles() packet he will reply you with a list of stored files in a Files() packet. """ MyID = my_id.getLocalID() if not customer_idurl: customer_idurl = MyID if not str(target_supplier).isdigit(): RemoteID = target_supplier else: RemoteID = contactsdb.supplier(target_supplier, customer_idurl=customer_idurl) if not RemoteID: lg.warn("RemoteID is empty target_supplier=%s" % str(target_supplier)) return None if _Debug: lg.out(_DebugLevel, "p2p_service.SendListFiles to %s" % nameurl.GetName(RemoteID)) if not key_id: key_id = global_id.MakeGlobalID(idurl=customer_idurl, key_alias='customer') PacketID = "%s:%s" % (key_id, packetid.UniqueID(), ) Payload = settings.ListFilesFormat() result = signed.Packet( Command=commands.ListFiles(), OwnerID=MyID, CreatorID=MyID, PacketID=PacketID, Payload=Payload, RemoteID=RemoteID, ) gateway.outbox(result, wide=wide, callbacks=callbacks) return result
def SendRequestService(remote_idurl, service_name, json_payload={}, wide=False, callbacks={}, timeout=10): service_info = { 'name': service_name, 'payload': json_payload, } service_info_raw = serialization.DictToBytes(service_info) if _Debug: lg.out( _DebugLevel, 'p2p_service.SendRequestService "%s" to %s with %r' % (service_name, remote_idurl, service_info)) result = signed.Packet( commands.RequestService(), my_id.getLocalID(), my_id.getLocalID(), packetid.UniqueID(), service_info_raw, remote_idurl, ) gateway.outbox(result, wide=wide, callbacks=callbacks, response_timeout=timeout) return result
def SendContacts(remote_idurl, json_payload={}, wide=False, callbacks={}): """ """ MyID = my_id.getLocalID() if _Debug: lg.out( _DebugLevel, "p2p_service.SendContacts to %s" % nameurl.GetName(remote_idurl)) PacketID = packetid.UniqueID() try: json_payload['type'] json_payload['space'] except: lg.err() return None Payload = serialization.DictToBytes(json_payload) result = signed.Packet( Command=commands.Contacts(), OwnerID=MyID, CreatorID=MyID, PacketID=PacketID, Payload=Payload, RemoteID=remote_idurl, ) gateway.outbox(result, wide=wide, callbacks=callbacks) return result
def ListFiles(request): """ We will want to use this to see what needs to be resent, and expect normal case is very few missing. This is to build the ``Files()`` we are holding for a customer. """ if not driver.is_started("service_supplier"): return SendFail(request, "supplier service is off") MyID = my_id.getLocalID() RemoteID = request.OwnerID PacketID = request.PacketID Payload = request.Payload if _Debug: lg.out( _DebugLevel, "p2p_service.ListFiles from [%s], format is %s" % (nameurl.GetName(request.OwnerID), Payload) ) custdir = settings.getCustomersFilesDir() ownerdir = os.path.join(custdir, nameurl.UrlFilename(request.OwnerID)) if not os.path.isdir(ownerdir): if _Debug: lg.out(_DebugLevel, "p2p_service.ListFiles did not find customer dir " + ownerdir) src = PackListFiles("", Payload) result = signed.Packet(commands.Files(), MyID, MyID, PacketID, src, RemoteID) gateway.outbox(result) return result plaintext = TreeSummary(ownerdir) if _Debug: lg.out(_DebugLevel + 4, "\n%s" % (plaintext)) src = PackListFiles(plaintext, Payload) result = signed.Packet(commands.Files(), MyID, MyID, PacketID, src, RemoteID) gateway.outbox(result) return result
def SendCancelService(remote_idurl, service_name, json_payload={}, wide=False, callbacks={}): service_info = { 'name': service_name, 'payload': json_payload, } service_info_raw = json.dumps(service_info) if _Debug: lg.out( _DebugLevel, 'p2p_service.SendCancelService "%s" to %s with %d bytes payload' % (service_name, remote_idurl, len(service_info_raw))) result = signed.Packet( commands.CancelService(), my_id.getLocalID(), my_id.getLocalID(), packetid.UniqueID(), service_info_raw, remote_idurl, ) gateway.outbox(result, wide=wide, callbacks=callbacks) return result
def SendKey( remote_idurl, encrypted_key_data, packet_id=None, wide=False, callbacks={}, timeout=10, ): if packet_id is None: packet_id = packetid.UniqueID() if _Debug: lg.out( _DebugLevel, "p2p_service.SendKey [%s] to %s with %d bytes encrypted key data" % (packet_id, remote_idurl, len(encrypted_key_data))) outpacket = signed.Packet( Command=commands.Key(), OwnerID=my_id.getLocalID(), CreatorID=my_id.getLocalID(), PacketID=packet_id, Payload=encrypted_key_data, RemoteID=remote_idurl, ) gateway.outbox(outpacket, wide=wide, callbacks=callbacks, response_timeout=timeout) return outpacket
def SendCancelService(remote_idurl, service_name, json_payload={}, wide=False, callbacks={}): service_info = { 'name': service_name, 'payload': json_payload, } service_info_raw = serialization.DictToBytes(service_info) if _Debug: lg.out( _DebugLevel, 'p2p_service.SendCancelService "%s" to %s with %d bytes payload' % (service_name, remote_idurl, len(service_info_raw))) result = signed.Packet( Command=commands.CancelService(), OwnerID=my_id.getLocalID(), CreatorID=my_id.getLocalID(), PacketID=packetid.UniqueID(), Payload=service_info_raw, RemoteID=remote_idurl, ) gateway.outbox(result, wide=wide, callbacks=callbacks) return result
def SendAuditKey(remote_idurl, encrypted_payload, packet_id=None, timeout=10, wide=False, callbacks={}): if _Debug: lg.out( _DebugLevel, "p2p_service.SendAuditKey to %s with %d bytes in json payload data" % (remote_idurl, len(encrypted_payload))) if packet_id is None: packet_id = packetid.UniqueID() outpacket = signed.Packet( Command=commands.AuditKey(), OwnerID=my_id.getLocalID(), CreatorID=my_id.getLocalID(), PacketID=packet_id, Payload=encrypted_payload, RemoteID=remote_idurl, ) gateway.outbox(outpacket, wide=wide, callbacks=callbacks, response_timeout=timeout) return outpacket
def SendToIDs(idlist, wide=False, ack_handler=None, timeout_handler=None, response_timeout=20): """ Same, but send to many IDs and also check previous packets to not re-send. """ global _PropagateCounter if _Debug: lg.out(_DebugLevel, "propagate.SendToIDs to %d users, wide=%s" % (len(idlist), wide)) if ack_handler is None: ack_handler = HandleAck if timeout_handler is None: timeout_handler = HandleTimeOut LocalIdentity = my_id.getLocalIdentity() Payload = strng.to_bin(LocalIdentity.serialize()) alreadysent = set() totalsent = 0 inqueue = {} found_previous_packets = 0 for pkt_out in packet_out.queue(): if id_url.is_in(pkt_out.remote_idurl, idlist, as_field=False): if pkt_out.description.count('Identity'): if pkt_out.remote_idurl not in inqueue: inqueue[pkt_out.remote_idurl] = 0 inqueue[pkt_out.remote_idurl] += 1 found_previous_packets += 1 for contact in idlist: if not contact: continue if contact in alreadysent: # just want to send once even if both customer and supplier continue if contact in inqueue and inqueue[contact] > 2: # now only 2 protocols is working: tcp and udp if _Debug: lg.out(_DebugLevel, ' skip sending [Identity] to %s, packet already in the queue' % contact) continue p = signed.Packet( Command=commands.Identity(), OwnerID=my_id.getLocalID(), CreatorID=my_id.getLocalID(), PacketID=('propagate:%d:%s' % (_PropagateCounter, packetid.UniqueID())), Payload=Payload, RemoteID=contact, ) _PropagateCounter += 1 if _Debug: lg.out(_DebugLevel, " sending [Identity] to %s" % nameurl.GetName(contact)) gateway.outbox(p, wide, response_timeout=response_timeout, callbacks={ commands.Ack(): ack_handler, commands.Fail(): ack_handler, None: timeout_handler, }) if wide: # this is a ping packet - need to clear old info p2p_stats.ErasePeerProtosStates(contact) p2p_stats.EraseMyProtosStates(contact) alreadysent.add(contact) totalsent += 1 del alreadysent return totalsent
def SendRetreiveCoin(remote_idurl, query, wide=False, callbacks={}): if _Debug: lg.out(_DebugLevel, "p2p_service.SendRetreiveCoin to %s" % remote_idurl) outpacket = signed.Packet( commands.Coin(), my_id.getLocalID(), my_id.getLocalID(), packetid.UniqueID(), json.dumps(query), remote_idurl ) gateway.outbox(outpacket, wide=wide, callbacks=callbacks) return outpacket
def SendDeleteBackup(SupplierID, BackupID): if _Debug: lg.out(_DebugLevel, "p2p_service.SendDeleteBackup SupplierID=%s BackupID=%s" % (SupplierID, BackupID)) MyID = my_id.getLocalID() PacketID = packetid.RemotePath(BackupID) RemoteID = SupplierID result = signed.Packet(commands.DeleteBackup(), MyID, MyID, PacketID, "", RemoteID) gateway.outbox(result) return result
def SendDeleteFile(SupplierID, pathID): if _Debug: lg.out(_DebugLevel, "p2p_service.SendDeleteFile SupplierID=%s PathID=%s" % (SupplierID, pathID)) MyID = my_id.getLocalID() PacketID = pathID RemoteID = SupplierID result = signed.Packet(commands.DeleteFile(), MyID, MyID, PacketID, "", RemoteID) gateway.outbox(result) return result
def SendAckNoRequest(remoteID, packetid, response="", wide=False, callbacks={}): result = signed.Packet(commands.Ack(), my_id.getLocalID(), my_id.getLocalID(), packetid, response, remoteID) if _Debug: lg.out( _DebugLevel, "p2p_service.SendAckNoRequest %s to %s response: %s ..." % (result.PacketID, result.RemoteID, str(response)[:15]), ) gateway.outbox(result, wide=wide, callbacks=callbacks)
def SendDeleteBackup(SupplierID, BackupID): if _Debug: lg.out(_DebugLevel, "p2p_service.SendDeleteBackup SupplierID=%s BackupID=%s " % (SupplierID, BackupID)) MyID = my_id.getLocalID() PacketID = BackupID RemoteID = SupplierID result = signed.Packet(commands.DeleteBackup(), MyID, MyID, PacketID, "", RemoteID) gateway.outbox(result) return result
def SendRetrieveCoin(remote_idurl, query, wide=False, callbacks={}): if _Debug: lg.out(_DebugLevel, "p2p_service.SendRetrieveCoin to %s" % remote_idurl) outpacket = signed.Packet(commands.RetrieveCoin(), my_id.getLocalID(), my_id.getLocalID(), packetid.UniqueID(), json.dumps(query), remote_idurl) gateway.outbox(outpacket, wide=wide, callbacks=callbacks) return outpacket
def SendDeleteListBackups(SupplierID, ListBackupIDs): if _Debug: lg.out(_DebugLevel, "p2p_service.SendDeleteListBackups SupplierID=%s BackupIDs: %s" % (SupplierID, ListBackupIDs)) MyID = my_id.getLocalID() PacketID = packetid.UniqueID() RemoteID = SupplierID Payload = '\n'.join(ListBackupIDs) result = signed.Packet(commands.DeleteBackup(), MyID, MyID, PacketID, Payload, RemoteID) gateway.outbox(result) return result
def SendCoin(remote_idurl, coins, packet_id=None, wide=False, callbacks={}): if _Debug: lg.out(_DebugLevel, "p2p_service.SendCoin to %s" % remote_idurl) if packet_id is None: packet_id = packetid.UniqueID() outpacket = signed.Packet( commands.Coin(), my_id.getLocalID(), my_id.getLocalID(), packet_id, json.dumps(coins), remote_idurl ) gateway.outbox(outpacket, wide=wide, callbacks=callbacks) return outpacket
def _send(c): from transport.udp import udp_stream for idurl in sys.argv[2:]: print('_send', list(udp_stream.streams().keys())) p = signed.Packet(commands.Data(), my_id.getLocalID(), my_id.getLocalID(), 'packet%d' % c, bpio.ReadBinaryFile(sys.argv[1]), idurl) gateway.outbox(p) if c > 1: reactor.callLater(0.01, _send, c - 1)
def SendCancelService(remote_idurl, service_info, callbacks={}): if _Debug: lg.out( _DebugLevel, "p2p_service.SendCancelService [%s]" % service_info.replace('\n', ' ')[:40]) result = signed.Packet(commands.CancelService(), my_id.getLocalID(), my_id.getLocalID(), packetid.UniqueID(), service_info, remote_idurl) gateway.outbox(result, callbacks=callbacks) return result
def SendCoin(remote_idurl, coins, packet_id=None, wide=False, callbacks={}): if _Debug: lg.out(_DebugLevel, "p2p_service.SendCoin to %s with %d records" % (remote_idurl, len(coins))) if packet_id is None: packet_id = packetid.UniqueID() outpacket = signed.Packet( commands.Coin(), my_id.getLocalID(), my_id.getLocalID(), packet_id, serialization.DictToBytes(coins), remote_idurl) gateway.outbox(outpacket, wide=wide, callbacks=callbacks) return outpacket
def SendAck(packettoack, response='', wide=False, callbacks={}, packetid=None): result = signed.Packet(commands.Ack(), my_id.getLocalID(), my_id.getLocalID(), packetid or packettoack.PacketID, response, packettoack.OwnerID) if _Debug: lg.out( _DebugLevel, "p2p_service.SendAck %s to %s with %d bytes" % (result.PacketID, result.RemoteID, len(response))) gateway.outbox(result, wide=wide, callbacks=callbacks) return result
def SendRequestService(remote_idurl, service_info, wide=False, callbacks={}): if _Debug: lg.out( _DebugLevel, "p2p_service.SendRequestService to %s [%s]" % (nameurl.GetName(remote_idurl), service_info.replace('\n', ' ')[:40])) result = signed.Packet(commands.RequestService(), my_id.getLocalID(), my_id.getLocalID(), packetid.UniqueID(), service_info, remote_idurl) gateway.outbox(result, wide=wide, callbacks=callbacks) return result
def SendIdentity(remote_idurl, wide=False, callbacks={}): """ """ if _Debug: lg.out( _DebugLevel, "p2p_service.SendIdentity to %s" % nameurl.GetName(remote_idurl)) result = signed.Packet(commands.Identity(), my_id.getLocalID(), my_id.getLocalID(), 'identity', my_id.getLocalIdentity().serialize(), remote_idurl) gateway.outbox(result, wide=wide, callbacks=callbacks) return result
def _send(c): from transport.udp import udp_stream for idurl in sys.argv[2:]: print '_send', udp_stream.streams().keys() p = signed.Packet(commands.Data(), my_id.getLocalID(), my_id.getLocalID(), 'packet%d' % c, bpio.ReadBinaryFile(sys.argv[1]), idurl) gateway.outbox(p) if c > 1: reactor.callLater(0.01, _send, c - 1)
def SendAckNoRequest(remoteID, packetid, response='', wide=False, callbacks={}): result = signed.Packet(commands.Ack(), my_id.getLocalID(), my_id.getLocalID(), packetid, response, remoteID) if _Debug: lg.out( _DebugLevel, "p2p_service.SendAckNoRequest %s to %s response: %s ..." % (result.PacketID, result.RemoteID, str(response)[:15])) gateway.outbox(result, wide=wide, callbacks=callbacks)
def SendCancelService(remote_idurl, service_info, callbacks={}): if _Debug: lg.out(_DebugLevel, "p2p_service.SendCancelService [%s]" % service_info.replace("\n", " ")[:40]) result = signed.Packet( commands.CancelService(), my_id.getLocalID(), my_id.getLocalID(), packetid.UniqueID(), service_info, remote_idurl, ) gateway.outbox(result, callbacks=callbacks) return result
def SendAckNoRequest(remoteID, packetid, response='', wide=False, callbacks={}): result = signed.Packet( Command=commands.Ack(), OwnerID=my_id.getLocalID(), CreatorID=my_id.getLocalID(), PacketID=packetid, Payload=response, RemoteID=remoteID, ) if _Debug: lg.out(_DebugLevel, "p2p_service.SendAckNoRequest packetID=%s to %s with %d bytes" % ( result.PacketID, result.RemoteID, len(response))) gateway.outbox(result, wide=wide, callbacks=callbacks)
def SendDeleteListBackups(SupplierID, ListBackupIDs): if _Debug: lg.out( _DebugLevel, "p2p_service.SendDeleteListBackups SupplierID=%s BackupIDs number: %d" % (SupplierID, len(ListBackupIDs)), ) MyID = my_id.getLocalID() PacketID = packetid.UniqueID() RemoteID = SupplierID Payload = "\n".join(ListBackupIDs) result = signed.Packet(commands.DeleteBackup(), MyID, MyID, PacketID, Payload, RemoteID) gateway.outbox(result) return result
def SendFailNoRequest(remoteID, packetID, response=''): result = signed.Packet( Command=commands.Fail(), OwnerID=my_id.getLocalID(), CreatorID=my_id.getLocalID(), PacketID=packetID, Payload=response, RemoteID=remoteID, ) if _Debug: lg.out(_DebugLevel, "p2p_service.SendFailNoRequest packetID=%s to %s" % (result.PacketID, result.RemoteID)) gateway.outbox(result) return result
def SendRetrieveCoin(remote_idurl, query, wide=False, callbacks={}): if _Debug: lg.out(_DebugLevel, "p2p_service.SendRetrieveCoin to %s" % remote_idurl) outpacket = signed.Packet( Command=commands.RetrieveCoin(), OwnerID=my_id.getLocalID(), CreatorID=my_id.getLocalID(), PacketID=packetid.UniqueID(), Payload=serialization.DictToBytes(query), RemoteID=remote_idurl, ) gateway.outbox(outpacket, wide=wide, callbacks=callbacks) return outpacket
def SendDeleteListPaths(SupplierID, ListPathIDs): if _Debug: lg.out( _DebugLevel, "p2p_service.SendDeleteListPaths SupplierID=%s PathIDs number: %d" % (SupplierID, len(ListPathIDs))) MyID = my_id.getLocalID() PacketID = packetid.UniqueID() RemoteID = SupplierID Payload = '\n'.join(ListPathIDs) result = signed.Packet(commands.DeleteFile(), MyID, MyID, PacketID, Payload, RemoteID) gateway.outbox(result) return result
def SendFail(request, response="", remote_idurl=None): if remote_idurl is None: remote_idurl = request.OwnerID result = signed.Packet( commands.Fail(), my_id.getLocalID(), my_id.getLocalID(), request.PacketID, response, remote_idurl ) if _Debug: lg.out( _DebugLevel, "p2p_service.SendFail %s to %s response: %s ..." % (result.PacketID, result.RemoteID, str(response)[:15]), ) gateway.outbox(result) return result
def doSendMyIdentity(self, *args, **kwargs): """ Action method. """ global _KnownChannels self.ping_attempts += 1 if self.fake_identity: identity_object = self.fake_identity else: identity_object = my_id.getLocalIdentity() if not identity_object.Valid(): raise Exception('can not use invalid identity for ping') if self.channel_counter: packet_id = '%s:%d:%d:%s' % (self.channel, _KnownChannels[self.channel], self.ping_attempts, packetid.UniqueID()) else: packet_id = '%s:%d:%s' % (self.channel, self.ping_attempts, packetid.UniqueID()) ping_packet = signed.Packet( Command=commands.Identity(), OwnerID=my_id.getIDURL(), CreatorID=my_id.getIDURL(), PacketID=packet_id, Payload=strng.to_bin(identity_object.serialize()), RemoteID=self.remote_idurl, ) if self.skip_outbox: packet_out.create( outpacket=ping_packet, wide=True, response_timeout=self.ack_timeout, callbacks={ commands.Ack(): lambda response, info: self.automat('ack-received', response=response, info=info), commands.Fail(): lambda response, info: self.automat('fail-received', response=response, info=info), None: lambda pkt_out: self.automat('ack-timeout', pkt_out), }, keep_alive=self.keep_alive, ) else: gateway.outbox( outpacket=ping_packet, wide=True, response_timeout=self.ack_timeout, callbacks={ commands.Ack(): lambda response, info: self.automat('ack-received', response=response, info=info), commands.Fail(): lambda response, info: self.automat('fail-received', response=response, info=info), None: lambda pkt_out: self.automat('ack-timeout', pkt_out), }, keep_alive=self.keep_alive, ) if _Debug: lg.args(_DebugLevel, packet_id=packet_id, remote_idurl=self.remote_idurl, ping_attempts=self.ping_attempts)
def SendFailNoRequest(remoteID, packetID, response=''): result = signed.Packet( commands.Fail(), my_id.getLocalID(), my_id.getLocalID(), packetID, response, remoteID, ) if _Debug: lg.out( _DebugLevel, "p2p_service.SendFailNoRequest packetID=%s to %s" % (result.PacketID, result.RemoteID)) gateway.outbox(result) return result
def RequestIdentity(request): """ Someone is requesting a copy of our current identity. Already verified that they are a contact. Can also be used as a sort of "ping" test to make sure we are alive. """ if _Debug: lg.out(_DebugLevel, "p2p_service.RequestIdentity from %s" % request.OwnerID) MyID = my_id.getLocalID() RemoteID = request.OwnerID PacketID = request.PacketID identitystr = my_id.getLocalIdentity().serialize() result = signed.Packet(commands.Identity(), MyID, MyID, PacketID, identitystr, RemoteID) gateway.outbox(result, False)
def SendCoin(remote_idurl, coins, packet_id=None, wide=False, callbacks={}): if _Debug: lg.out(_DebugLevel, "p2p_service.SendCoin to %s with %d records" % (remote_idurl, len(coins))) if packet_id is None: packet_id = packetid.UniqueID() outpacket = signed.Packet( Command=commands.Coin(), OwnerID=my_id.getLocalID(), CreatorID=my_id.getLocalID(), PacketID=packet_id, Payload=serialization.DictToBytes(coins, keys_to_text=True), RemoteID=remote_idurl, ) gateway.outbox(outpacket, wide=wide, callbacks=callbacks) return outpacket
def Retrieve(request): """ Customer is asking us for data he previously stored with us. We send with ``outboxNoAck()`` method because he will ask again if he does not get it """ # TODO: rename to RetreiveData() if not driver.is_started("service_supplier"): return SendFail(request, "supplier service is off") if not contactsdb.is_customer(request.OwnerID): lg.warn("had unknown customer " + request.OwnerID) SendFail(request, "not a customer") return filename = makeFilename(request.OwnerID, request.PacketID) if filename == "": lg.warn("had empty filename") SendFail(request, "empty filename") return if not os.path.exists(filename): lg.warn("did not find requested file locally " + filename) SendFail(request, "did not find requested file locally") return if not os.access(filename, os.R_OK): lg.warn("no read access to requested packet " + filename) SendFail(request, "no read access to requested packet") return data = bpio.ReadBinaryFile(filename) if not data: lg.warn("empty data on disk " + filename) SendFail(request, "empty data on disk") return outpacket = signed.Unserialize(data) del data if outpacket is None: lg.warn("Unserialize fails, not Valid packet " + filename) SendFail(request, "unserialize fails") return if not outpacket.Valid(): lg.warn("unserialized packet is not Valid " + filename) SendFail(request, "unserialized packet is not Valid") return if _Debug: lg.out( _DebugLevel, "p2p_service.Retrieve sending %r back to %s" % (outpacket, nameurl.GetName(outpacket.CreatorID)), ) gateway.outbox(outpacket, target=outpacket.CreatorID)
def doSuppliersSendDBInfo(self, arg): from p2p import contact_status lg.out(4, 'backup_db_keeper.doSuppliersSendDBInfo') packetID = settings.BackupIndexFileName() self.sentSuppliers.clear() src = bpio.ReadBinaryFile(settings.BackupIndexFilePath()) localID = my_id.getLocalID() b = encrypted.Block( localID, packetID, 0, key.NewSessionKey(), key.SessionKeyType(), True, src) Payload = b.Serialize() for supplierId in contactsdb.suppliers(): if not supplierId: continue if not contact_status.isOnline(supplierId): continue newpacket = signed.Packet( commands.Data(), localID, localID, packetID, Payload, supplierId) pkt_out = gateway.outbox(newpacket, callbacks={ commands.Ack(): self._supplier_acked, commands.Fail(): self._supplier_acked, }) self.sentSuppliers.add(supplierId) lg.out( 4, ' %s sending to %s' % (pkt_out, nameurl.GetName(supplierId)))
def SendAck(packettoack, response="", wide=False, callbacks={}, packetid=None): result = signed.Packet( commands.Ack(), my_id.getLocalID(), my_id.getLocalID(), packetid or packettoack.PacketID, response, packettoack.OwnerID, ) if _Debug: lg.out( _DebugLevel, "p2p_service.SendAck %s to %s response: %s ..." % (result.PacketID, result.RemoteID, str(response)[:15]), ) gateway.outbox(result, wide=wide, callbacks=callbacks) return result
def SendIdentity(remote_idurl, wide=False, callbacks={}): """ """ if _Debug: lg.out(_DebugLevel, "p2p_service.SendIdentity to %s" % nameurl.GetName(remote_idurl)) result = signed.Packet( commands.Identity(), my_id.getLocalID(), my_id.getLocalID(), "identity", my_id.getLocalIdentity().serialize(), remote_idurl, ) gateway.outbox(result, wide=wide, callbacks=callbacks) return result
def SendMessage(remote_idurl, messagebody, packet_id=None): """ Send command.Message() packet to remote peer. """ global _OutgoingMessageCallback if not packet_id: packet_id = packetid.UniqueID() remote_identity = identitycache.FromCache(remote_idurl) if remote_identity is None: d = identitycache.immediatelyCaching(remote_idurl, 20) d.addCallback(lambda src: SendMessage( remote_idurl, messagebody, packet_id)) d.addErrback(lambda err: lg.warn('failed to retrieve ' + remote_idurl)) return d Amessage = MessageClass(remote_identity, messagebody) Payload = misc.ObjectToString(Amessage) lg.out(6, "message.SendMessage to %s with %d bytes" % (remote_idurl, len(Payload))) outpacket = signed.Packet( commands.Message(), my_id.getLocalID(), my_id.getLocalID(), packet_id, Payload, remote_idurl) result = gateway.outbox(outpacket, wide=True) if _OutgoingMessageCallback: _OutgoingMessageCallback(result, messagebody, remote_identity, packet_id) return result
def SendRequestListFiles(supplierNumORidurl): if not str(supplierNumORidurl).isdigit(): RemoteID = supplierNumORidurl else: RemoteID = contactsdb.supplier(supplierNumORidurl) if not RemoteID: lg.warn("RemoteID is empty supplierNumORidurl=%s" % str(supplierNumORidurl)) return None if _Debug: lg.out(_DebugLevel, "p2p_service.SendRequestListFiles [%s]" % nameurl.GetName(RemoteID)) MyID = my_id.getLocalID() PacketID = packetid.UniqueID() Payload = settings.ListFilesFormat() result = signed.Packet(commands.ListFiles(), MyID, MyID, PacketID, Payload, RemoteID) gateway.outbox(result) return result
def SendRequestService(remote_idurl, service_info, wide=False, callbacks={}): if _Debug: lg.out( _DebugLevel, "p2p_service.SendRequestService to %s [%s]" % (nameurl.GetName(remote_idurl), service_info.replace("\n", " ")[:40]), ) result = signed.Packet( commands.RequestService(), my_id.getLocalID(), my_id.getLocalID(), packetid.UniqueID(), service_info, remote_idurl, ) gateway.outbox(result, wide=wide, callbacks=callbacks) return result
def SendData(raw_data, ownerID, creatorID, remoteID, packetID, callbacks={}): """ """ # TODO: newpacket = signed.Packet(commands.Data(), ownerID, creatorID, packetID, raw_data, remoteID) result = gateway.outbox(newpacket, callbacks=callbacks) return result
def doSuppliersRequestDBInfo(self, arg): lg.out(4, 'backup_db_keeper.doSuppliersRequestDBInfo') packetID = settings.BackupIndexFileName() self.requestedSuppliers.clear() Payload = '' localID = my_id.getLocalID() for supplierId in contactsdb.suppliers(): if not supplierId: continue newpacket = signed.Packet( commands.Retrieve(), localID, localID, packetID, Payload, supplierId) gateway.outbox(newpacket, callbacks={ commands.Data(): self._supplier_response, commands.Fail(): self._supplier_response, }) self.requestedSuppliers.add(supplierId)
def doSuppliersRequestIndexFile(self, arg): """ Action method. """ if _Debug: lg.out(_DebugLevel, 'index_synchronizer.doSuppliersRequestIndexFile') if driver.is_started('service_backups'): from storage import backup_control self.current_local_revision = backup_control.revision() else: self.current_local_revision = -1 self.latest_supplier_revision = -1 self.requesting_suppliers.clear() self.requested_suppliers_number = 0 packetID = settings.BackupIndexFileName() localID = my_id.getLocalID() for supplierId in contactsdb.suppliers(): if not supplierId: continue if not contact_status.isOnline(supplierId): continue newpacket = signed.Packet( commands.Retrieve(), localID, localID, packetID, '', supplierId) pkt_out = gateway.outbox(newpacket, callbacks={ commands.Data(): self._on_supplier_response, commands.Fail(): self._on_supplier_response, }) if pkt_out: self.requesting_suppliers.add(supplierId) self.requested_suppliers_number += 1 if _Debug: lg.out(_DebugLevel, ' %s sending to %s' % (pkt_out, nameurl.GetName(supplierId)))
def doSuppliersSendIndexFile(self, arg): """ Action method. """ if _Debug: lg.out(_DebugLevel, 'index_synchronizer.doSuppliersSendIndexFile') packetID = settings.BackupIndexFileName() self.sending_suppliers.clear() self.sent_suppliers_number = 0 src = bpio.ReadBinaryFile(settings.BackupIndexFilePath()) localID = my_id.getLocalID() b = encrypted.Block( localID, packetID, 0, key.NewSessionKey(), key.SessionKeyType(), True, src) Payload = b.Serialize() for supplierId in contactsdb.suppliers(): if not supplierId: continue if not contact_status.isOnline(supplierId): continue newpacket = signed.Packet( commands.Data(), localID, localID, packetID, Payload, supplierId) pkt_out = gateway.outbox(newpacket, callbacks={ commands.Ack(): self._on_supplier_acked, commands.Fail(): self._on_supplier_acked, }) if pkt_out: self.sending_suppliers.add(supplierId) self.sent_suppliers_number += 1 if _Debug: lg.out(_DebugLevel, ' %s sending to %s' % (pkt_out, nameurl.GetName(supplierId)))
def mine_and_send(self, data): from transport import gateway outpacket = '' gateway.outbox(outpacket)
def SendBroadcastMessage(outpacket): if _Debug: lg.out(_DebugLevel, "p2p_service.SendBroadcastMessage to %s" % outpacket.RemoteID) gateway.outbox(outpacket) return outpacket
def SendFailNoRequest(remoteID, packetID, response): result = signed.Packet(commands.Fail(), my_id.getLocalID(), my_id.getLocalID(), packetID, response, remoteID) if _Debug: lg.out(_DebugLevel, "p2p_service.SendFailNoRequest %s to %s" % (result.PacketID, result.RemoteID)) gateway.outbox(result) return result