def SendSingleCustomer(idurl, response_callback=None):
dhnio.Dprint(6, "identitypropagate.SendSingleCustomer [%s]" % nameurl.GetName(idurl))
MyID = misc.getLocalID()
packet = dhnpacket.dhnpacket(commands.Identity(), MyID, MyID, MyID, misc.getLocalIdentity().serialize(), idurl)
transport_control.outboxNoAck(packet)
if response_callback is not None:
transport_control.RegisterInterest(response_callback, packet.RemoteID, packet.PacketID)
def CreateNewIdentity():
global _NewIdentity
dhncrypto.InitMyKey()
misc.loadLocalIdentity()
if misc.isLocalIdentityReady():
try:
lid = misc.getLocalIdentity()
lid.sign()
# misc.setLocalIdentity(lid)
# misc.saveLocalIdentity()
valid = lid.Valid()
except:
valid = False
dhnio.DprintException()
if valid:
_NewIdentity = lid
return
dhnio.Dprint(2, 'identity_registrator.CreateNewIdentity existing local identity is not VALID')
login = dhnio.ReadTextFile(settings.UserNameFilename())
externalIP = dhnio.ReadTextFile(settings.ExternalIPFilename())
localIP = dhnio.ReadTextFile(settings.LocalIPFilename())
dhnio.Dprint(4, 'identity_registrator.CreateNewIdentity %s %s ' % (login, externalIP))
idurl = 'http://'+settings.IdentityServerName()+'/'+login.lower()+'.xml'
ident = identity.identity( )
ident.sources.append(idurl)
cdict = {}
if settings.enableTCP():
cdict['tcp'] = 'tcp://'+externalIP+':'+settings.getTCPPort()
if settings.enableCSpace() and transport_control._TransportCSpaceEnable:
cdict['cspace'] = 'cspace://'
if settings.getCSpaceKeyID() != '':
cdict['cspace'] += settings.getCSpaceKeyID()
if settings.enableUDP() and transport_control._TransportUDPEnable:
if stun.getUDPClient() is not None:
if stun.getUDPClient().externalAddress is not None: # _altStunAddress
cdict['udp'] = 'udp://'+stun.getUDPClient().externalAddress[0]+':'+str(stun.getUDPClient().externalAddress[1])
for c in misc.validTransports:
if cdict.has_key(c):
ident.contacts.append(cdict[c])
ident.publickey = dhncrypto.MyPublicKey()
ident.date = time.ctime() #time.strftime('%b %d, %Y')
revnum = dhnio.ReadTextFile(settings.RevisionNumberFile()).strip()
repo, location = misc.ReadRepoLocation()
ident.version = (revnum.strip() + ' ' + repo.strip() + ' ' + dhnio.osinfo().strip()).strip()
ident.sign()
dhnio.WriteFile(settings.LocalIdentityFilename()+'.new', ident.serialize())
_NewIdentity = ident
def SendIdentity(doAck=False):
"""
Register our identity with Central server.
"""
LocalIdentity = misc.getLocalIdentity()
dhnio.Dprint(4, "central_service.SendIdentity") #' version=[%s] contacts=[%s]" % (str(LocalIdentity.version), str(LocalIdentity.contacts)))
data = LocalIdentity.serialize()
ret = send2central(commands.Identity(), data, doAck, misc.getLocalID())
return ret
def RequestIdentity(request):
dhnio.Dprint(6, "p2p_service.RequestIdentity starting")
MyID = misc.getLocalID()
RemoteID = request.OwnerID
PacketID = request.PacketID
identitystr = misc.getLocalIdentity().serialize()
dhnio.Dprint(12, "p2p_service.RequestIdentity returning ")
result = dhnpacket.dhnpacket(commands.Identity(), MyID, MyID, PacketID, identitystr, RemoteID)
transport_control.outboxNoAck(result)
def SendRequestMarketList(doAck=True, packetID=None):
"""
Send my "Identity" packet to the Market server to request a list if my opened bids and offers.
"""
LocalIdentity = misc.getLocalIdentity()
dhnio.Dprint(4, "central_service.SendRequestMarketList")
data = LocalIdentity.serialize()
if packetID is None:
packetID = packetid.UniqueID()
# transport_control.RegisterInterest(MarketListAck, settings.MarketServerID(), packetID)
return send2market(commands.Identity(), data, doAck, packetID)
def _stop_transports():
stoplist = []
for proto in transport_control.ListSupportedProtocols():
contact = misc.getLocalIdentity().getProtoContact(proto)
if contact is None:
dhnio.Dprint(4, 'p2p_connector.UpdateTransports want to stop transport %s because not present in local identity' % proto)
stoplist.append(transport_control.StopProtocol(proto))
continue
proto_, host, port, filename = nameurl.UrlParse(contact)
if host.strip() == '':
continue
opts = transport_control.ProtocolOptions(proto)
if opts[0].strip() == '':
continue
if proto != proto_:
dhnio.Dprint(8, 'p2p_connector.UpdateTransports WARNING identity contact is %s, but proto is %s' % (contact, proto))
continue
#---tcp---
if proto == 'tcp':
if opts[0] != host:
dhnio.Dprint(4, 'p2p_connector.UpdateTransports want to stop transport [tcp] because IP changed')
stoplist.append(transport_control.StopProtocol(proto))
continue
if opts[1] != port:
dhnio.Dprint(4, 'p2p_connector.UpdateTransports want to stop transport [tcp] because port changed')
stoplist.append(transport_control.StopProtocol(proto))
continue
#---cspace---
if proto == 'cspace':
if opts[0] != host:
dhnio.Dprint(4, 'p2p_connector.UpdateTransports want to stop transport [cspace] because keyID changed: %s to %s' % (
host, opts[0]))
stoplist.append(transport_control.StopProtocol(proto))
continue
#---udp---
if proto == 'udp':
if opts[0] != host:
dhnio.Dprint(4, 'p2p_connector.UpdateTransports want to stop transport [udp] because IP were changed')
stoplist.append(transport_control.StopProtocol(proto))
continue
if opts[1] != port:
dhnio.Dprint(4, 'p2p_connector.UpdateTransports want to stop transport [udp] because port were changed')
stoplist.append(transport_control.StopProtocol(proto))
continue
if 'transport.transport-udp.transport-udp-port' in changes and settings.enableUDP():
dhnio.Dprint(4, 'p2p_connector.UpdateTransports want to stop transport [udp] because port were changed by user')
stoplist.append(transport_control.StopProtocol(proto))
continue
#need to wait before all listeners will be stopped
return DeferredList(stoplist)
def SendServers():
sendfile, sendfilename = tmpfile.make("propagate")
os.close(sendfile)
LocalIdentity = misc.getLocalIdentity()
dhnio.WriteFile(sendfilename, LocalIdentity.serialize())
dlist = []
for idurl in LocalIdentity.sources:
# sources for out identity are servers we need to send to
protocol, host, port, filename = nameurl.UrlParse(idurl)
port = settings.IdentityServerPort()
d = Deferred()
transport_tcp.sendsingle(sendfilename, host, port, do_status_report=False, result_defer=d, description='Identity')
dlist.append(d)
dl = DeferredList(dlist, consumeErrors=True)
return dl
def DoWeUseTheBestProto():
global _WorkingProtocols
#dhnio.Dprint(4, 'p2p_connector.DoWeUseTheBestProto _WorkingProtocols=%s' % str(_WorkingProtocols))
#if no incomming traffic - do nothing
if len(_WorkingProtocols) == 0:
return True
lid = misc.getLocalIdentity()
order = lid.getProtoOrder()
#if no protocols in local identity - do nothing
if len(order) == 0:
return True
first = order[0]
#if first contact in local identity is not working yet
#but there is another working methods - switch first method
if first not in _WorkingProtocols:
dhnio.Dprint(2, 'p2p_connector.DoWeUseTheBestProto first contact (%s) is not working! _WorkingProtocols=%s' % (first, str(_WorkingProtocols)))
return False
#if tcp contact is on first place and it is working - we are VERY HAPPY! - no need to change anything - return False
if first == 'tcp' and 'tcp' in _WorkingProtocols:
return True
#but if tcp method is not the first and it works - we want to TURN IT ON! - return True
if first != 'tcp' and 'tcp' in _WorkingProtocols:
dhnio.Dprint(2, 'p2p_connector.DoWeUseTheBestProto tcp is not first but it works _WorkingProtocols=%s' % str(_WorkingProtocols))
return False
#if we are using cspace and it is working - this is fantastic!
if transport_control._TransportCSpaceEnable:
if first == 'cspace' and 'cspace' in _WorkingProtocols:
return True
#if we are using udp and it is working - not so bad
if transport_control._TransportUDPEnable:
if first == 'udp' and 'udp' in _WorkingProtocols:
return True
#cspace seems to be working and first contact is not working - so switch to cspace
if transport_control._TransportCSpaceEnable:
if first != 'cspace' and 'cspace' in _WorkingProtocols:
dhnio.Dprint(2, 'p2p_connector.DoWeUseTheBestProto cspace is not first but it works _WorkingProtocols=%s' % str(_WorkingProtocols))
return False
#udp is working - we ca use it if all others is failed
if transport_control._TransportUDPEnable:
if first != 'udp' and 'udp' in _WorkingProtocols:
dhnio.Dprint(2, 'p2p_connector.DoWeUseTheBestProto udp is not first but it works _WorkingProtocols=%s' % str(_WorkingProtocols))
return False
#in other cases - do nothing
return True
def SendToID(idurl, AckHandler=None, Payload=None, NeedAck=False, wide=False):
dhnio.Dprint(8, "identitypropagate.SendToID [%s] NeedAck=%s" % (nameurl.GetName(idurl), str(NeedAck)))
thePayload = Payload
if thePayload is None:
thePayload = misc.getLocalIdentity().serialize()
packet = dhnpacket.dhnpacket(
commands.Identity(),
misc.getLocalID(), #MyID,
misc.getLocalID(), #MyID,
misc.getLocalID(), #PacketID,
thePayload,
idurl)
if AckHandler is not None:
transport_control.RegisterInterest(AckHandler, packet.RemoteID, packet.PacketID)
transport_control.outbox(packet, NeedAck, wide)
if wide:
# this is a ping packet - need to clear old info
transport_control.ErasePeerProtosStates(idurl)
transport_control.EraseMyProtosStates(idurl)
def SlowSendCustomers(delay=1):
global _SlowSendIsWorking
if _SlowSendIsWorking:
dhnio.Dprint(8, "identitypropagate.SlowSendCustomers slow send is working at the moment. skip.")
return
dhnio.Dprint(8, "identitypropagate.SlowSendCustomers delay=%s" % str(delay))
def _send(index, payload, delay):
global _SlowSendIsWorking
idurl = contacts.getCustomerID(index)
if not idurl:
_SlowSendIsWorking = False
return
transport_control.ClearAliveTime(idurl)
SendToID(idurl, Payload=payload, wide=True)
reactor.callLater(delay, _send, index+1, payload, delay)
_SlowSendIsWorking = True
payload = misc.getLocalIdentity().serialize()
_send(0, payload, delay)
def SendToIDs(idlist, AckHandler=None, wide=False):
dhnio.Dprint(8, "identitypropagate.SendToIDs to %d users" % len(idlist))
MyID = misc.getLocalID()
PacketID = MyID
LocalIdentity = misc.getLocalIdentity()
Payload = LocalIdentity.serialize()
Hash = dhncrypto.Hash(Payload)
alreadysent = set()
for contact in idlist:
if not contact:
continue
if contact in alreadysent:
# just want to send once even if both customer and supplier
continue
found_previous_packets = 0
for transfer_id in transport_control.transfers_by_idurl(contact):
ti = transport_control.transfer_by_id(transfer_id)
if ti and ti.description.count('Identity'):
found_previous_packets += 1
break
if found_previous_packets >= 3:
dhnio.Dprint(8, ' skip sending to %s' % contact)
continue
packet = dhnpacket.dhnpacket(
commands.Identity(),
misc.getLocalID(), #MyID,
misc.getLocalID(), #MyID,
misc.getLocalID(), #PacketID,
Payload,
contact)
dhnio.Dprint(8, " sending [Identity] to %s" % nameurl.GetName(contact))
if AckHandler is not None:
transport_control.RegisterInterest(AckHandler, packet.RemoteID, packet.PacketID)
transport_control.outboxNoAck(packet, wide)
if wide:
# this is a ping packet - need to clear old info
transport_control.ErasePeerProtosStates(contact)
transport_control.EraseMyProtosStates(contact)
alreadysent.add(contact)
del alreadysent
def PopWorkingProto():
global _WorkingProtocols
if len(_WorkingProtocols) == 0:
return
lid = misc.getLocalIdentity()
order = lid.getProtoOrder()
first = order[0]
wantedproto = ''
#if first contact in local identity is not working yet
#but there is another working methods - switch first method
if first not in _WorkingProtocols:
#take (but not remove) any item from the set
wantedproto = _WorkingProtocols.pop()
_WorkingProtocols.add(wantedproto)
# if q2q method is not the first but it works - switch to q2q
# disabled because we do not use q2q now
# if first != 'q2q' and 'q2q' in _WorkingProtocols:
# wantedproto = 'q2q'
#if udp method is not the first but it works - switch to udp
if transport_control._TransportUDPEnable:
if first != 'udp' and 'udp' in _WorkingProtocols:
wantedproto = 'udp'
#if cspace method is not the first but it works - switch to cspace
if transport_control._TransportCSpaceEnable:
if first != 'cspace' and 'cspace' in _WorkingProtocols:
wantedproto = 'cspace'
#if tcp method is not the first but it works - switch to tcp
if first != 'tcp' and 'tcp' in _WorkingProtocols:
wantedproto = 'tcp'
dhnio.Dprint(4, 'p2p_connector.PopWorkingProto will pop %s contact order=%s _WorkingProtocols=%s' % (wantedproto, str(order), str(_WorkingProtocols)))
# now move best proto on the top
# other users will use this method to send to us
lid.popProtoContact(wantedproto)
# save local id
# also need to propagate our identity
# other users must know our new contacts
misc.setLocalIdentity(lid)
misc.saveLocalIdentity()
def _start_transports():
startlist = []
for contact in misc.getLocalIdentity().getContacts():
proto, host, port, filename = nameurl.UrlParse(contact)
opts = transport_control.ProtocolOptions(proto)
if not transport_control.ProtocolIsSupported(proto):
if settings.transportIsEnabled(proto) and settings.transportIsInstalled(proto) and settings.transportReceivingIsEnabled(proto):
#---tcp---
if proto == 'tcp':
def _tcp_started(l, opts):
dhnio.Dprint(4, 'p2p_connector.UpdateTransports._tcp_started')
if l is not None:
transport_control.StartProtocol('tcp', l, opts[0], opts[1], opts[2])
return l
def _tcp_failed(x):
dhnio.Dprint(4, 'p2p_connector.UpdateTransports._tcp_failed WARNING: '+str(x))
return x
def _start_tcp(options):
dhnio.Dprint(4, 'p2p_connector.UpdateTransports._start_tcp on port %d' % int(options[1]))
d = transport_tcp.receive(int(options[1]))
d.addCallback(_tcp_started, options)
d.addErrback(_tcp_failed)
startlist.append(d)
def _upnp_result(result, options):
dhnio.Dprint(4, 'p2p_connector.UpdateTransports._upnp_result %s' % str(result))
if result is not None:
options[1] = str(result[1])
_start_tcp(options)
def _run_upnpc(port):
shutdowner.A('block')
run_upnpc.update(port)
shutdowner.A('unblock')
externalIP = misc.readExternalIP()
if opts is None:
opts = (externalIP, '', '')
opts = list(opts)
opts[0] = externalIP
opts[1] = settings.getTCPPort()
if settings.enableUPNP():
d = maybeDeferred(_run_upnpc, int(opts[1]))
d.addCallback(_upnp_result, opts)
else:
_start_tcp(opts)
#---cspace---
elif proto == 'cspace' and transport_control._TransportCSpaceEnable:
def _cspace_started(x, opts):
if not transport_cspace.registered():
dhnio.Dprint(4, 'p2p_connector.UpdateTransports._cspace_started WARNING not registered: ' + str(x))
return x
dhnio.Dprint(4, 'p2p_connector.UpdateTransports._cspace_started')
keyID = transport_cspace.keyID()
settings.setCSpaceKeyID(keyID)
opts[0] = keyID
l = transport_cspace.getListener()
transport_control.StartProtocol('cspace', l, opts[0], opts[1], opts[2])
return x
if opts is None:
opts = (settings.getCSpaceKeyID(), '', '')
opts = list(opts)
d = transport_cspace.init().addBoth(_cspace_started, opts)
startlist.append(d)
#---udp---
elif proto == 'udp' and transport_control._TransportUDPEnable:
def _udp_start(x, opts):
dhnio.Dprint(4, 'p2p_connector.UpdateTransports._udp_start')
if opts is None:
opts = (stun.getUDPClient().externalAddress[0], str(stun.getUDPClient().externalAddress[1]), '')
opts = list(opts)
opts[0] = stun.getUDPClient().externalAddress[0]
opts[1] = str(stun.getUDPClient().externalAddress[1])
transport_udp.init(stun.getUDPClient())
l = transport_udp.getListener()
if l is not None:
transport_control.StartProtocol('udp', l, opts[0], opts[1], opts[2])
return x
def _udp_failed(x):
dhnio.Dprint(4, 'p2p_connector.UpdateTransports._udp_failed')
return x
if stun.getUDPClient() is None or stun.getUDPClient().externalAddress is None:
d = stun.stunExternalIP(
close_listener=False,
internal_port=settings.getUDPPort(),
block_marker=shutdowner.A)
else:
d = succeed('')
d.addCallback(_udp_start, opts)
d.addErrback(_udp_failed)
startlist.append(d)
#need to wait before all listeners will be started
return DeferredList(startlist)
def UpdateIdentity():
global _RevisionNumber
global _WorkingProtocols
#getting local identity
lid = misc.getLocalIdentity()
nowip = misc.readExternalIP()
order = lid.getProtoOrder()
lid.clearContacts()
#prepare contacts data
cdict = {}
cdict['tcp'] = 'tcp://'+nowip+':'+settings.getTCPPort()
if transport_control._TransportSSHEnable:
cdict['ssh'] = 'ssh://'+nowip+':'+settings.getSSHPort()
if transport_control._TransportHTTPEnable:
cdict['http'] = 'http://'+nowip+':'+settings.getHTTPPort()
if transport_control._TransportQ2QEnable:
cdict['q2q'] = 'q2q://'+settings.getQ2Quserathost()
if transport_control._TransportEmailEnable:
cdict['email'] = 'email://'+settings.getEmailAddress()
if transport_control._TransportCSpaceEnable:
cdict['cspace'] = 'cspace://'+settings.getCSpaceKeyID()
if transport_control._TransportUDPEnable:
if stun.getUDPClient() is None or stun.getUDPClient().externalAddress is None:
cdict['udp'] = 'udp://'+nowip+':'+settings.getUDPPort()
else:
cdict['udp'] = 'udp://'+stun.getUDPClient().externalAddress[0]+':'+str(stun.getUDPClient().externalAddress[1])
#making full order list
for proto in cdict.keys():
if proto not in order:
order.append(proto)
#add contacts data to the local identity
#check if some transport is not installed
for proto in order:
if settings.transportIsEnabled(proto) and settings.transportReceivingIsEnabled(proto):
contact = cdict.get(proto, None)
if contact is not None:
lid.setProtoContact(proto, contact)
else:
# if protocol is disabled - mark this
# because we may want to turn it on in the future
_WorkingProtocols.discard(proto)
#misc.setLocalIdentity(lid)
del order
# #if IP is not external and upnp configuration was failed for some reasons
# #we want to use another contact methods, NOT tcp or ssh
# if IPisLocal() and run_upnpc.last_result('tcp') != 'upnp-done':
# dhnio.Dprint(4, 'p2p_connector.update_identity want to push tcp contact: local IP, no upnp ...')
# lid.pushProtoContact('tcp')
# misc.setLocalIdentity(lid)
#update software version number
revnum = _RevisionNumber.strip()
repo, location = misc.ReadRepoLocation()
lid.version = (revnum.strip() + ' ' + repo.strip() + ' ' + dhnio.osinfo().strip()).strip()
#generate signature with changed content
lid.sign()
#remember the identity
misc.setLocalIdentity(lid)
#finally saving local identity
misc.saveLocalIdentity()
dhnio.Dprint(4, 'p2p_connector.UpdateIdentity')
dhnio.Dprint(4, ' version: %s' % str(lid.version))
dhnio.Dprint(4, ' contacts: %s' % str(lid.contacts))
