def isConnectionAlive(self, *args, **kwargs):
# miss = 0
if driver.is_on('service_udp_datagrams'):
from lib import udp
if time.time() - udp.get_last_datagram_time() < 60:
if settings.enableUDP() and settings.enableUDPreceiving():
return True
# else:
# miss += 1
if driver.is_on('service_gateway'):
from transport import gateway
if time.time() - gateway.last_inbox_time() < 60:
return True
transport_states = [
t.state for t in list(gateway.transports().values())
]
if 'LISTENING' in transport_states:
return True
if 'STARTING' in transport_states:
return True
# else:
# miss += 1
# if miss >= 2:
# return True
# return False ... still testing that approach
return True
def isConnectionAlive(self, arg):
# miss = 0
if driver.is_on('service_udp_datagrams'):
from lib import udp
if time.time() - udp.get_last_datagram_time() < 60:
if settings.enableUDP() and settings.enableUDPreceiving():
return True
# else:
# miss += 1
if driver.is_on('service_gateway'):
from transport import gateway
if time.time() - gateway.last_inbox_time() < 60:
return True
transport_states = map(lambda t: t.state,
gateway.transports().values())
if 'LISTENING' in transport_states:
return True
if 'STARTING' in transport_states:
return True
# else:
# miss += 1
# if miss >= 2:
# return True
return True # testing
return False
def _available_transports(self):
from main import settings
atransports = []
if settings.enableTCP() and settings.enableTCPreceiving() and settings.enableTCPsending():
atransports.append('service_tcp_transport')
if settings.enableUDP() and settings.enableUDPreceiving() and settings.enableUDPsending():
atransports.append('service_udp_transport')
return atransports
def dependent_on(self):
from main import settings
depends = ['service_gateway',
'service_identity_propagate', ]
if settings.enableTCP():
depends.append('service_tcp_transport')
if settings.enableUDP():
depends.append('service_udp_transport')
return depends
def _available_transports(self):
from main import settings
atransports = []
if settings.enableTCP() and settings.enableTCPreceiving(
) and settings.enableTCPsending():
atransports.append('service_tcp_transport')
if settings.enableUDP() and settings.enableUDPreceiving(
) and settings.enableUDPsending():
atransports.append('service_udp_transport')
return atransports
def dependent_on(self):
from main import settings
depends = ['service_gateway',
'service_identity_propagate', ]
if settings.enableTCP():
depends.append('service_tcp_transport')
if settings.enableUDP():
depends.append('service_udp_transport')
# if settings.enablePROXY():
# depends.append('service_proxy_transport')
return depends
def buildDefaultIdentity(name='', ip='', idurls=[]):
"""
Use some local settings and config files to create some new identity.
Nice to provide a user name or it will have a form like: [ip_address]_[date].
"""
if not ip:
ip = misc.readExternalIP()
if not name:
name = ip.replace('.', '-') + '_' + time.strftime('%M%S')
lg.out(4, 'my_id.buildDefaultIdentity: %s %s' % (name, ip))
# create a new identity object
# it is stored in memory and another copy on disk drive
ident = identity.identity(xmlsrc=identity.default_identity_src)
# this is my IDURL address
# you can have many IDURL locations for same identity
# just need to keep all them synchronized
# this is identity propagate procedure, see p2p/propagate.py
if len(idurls) == 0:
idurls.append(b'http://127.0.0.1/%s.xml' % strng.to_bin(name.lower()))
for idurl in idurls:
ident.sources.append(strng.to_bin(idurl.strip()))
# create a full list of needed transport methods
# to be able to accept incoming traffic from other nodes
new_contacts, new_order = buildProtoContacts(ident)
if len(new_contacts) == 0:
if settings.enableTCP() and settings.enableTCPreceiving():
new_contacts['tcp'] = b'tcp://' + strng.to_bin(
ip) + b':' + strng.to_bin(str(settings.getTCPPort()))
new_order.append('tcp')
if settings.enableUDP() and settings.enableUDPreceiving():
_, servername, _, _ = nameurl.UrlParse(ident.sources[0])
new_contacts['udp'] = b'udp://' + strng.to_bin(
name.lower()) + b'@' + strng.to_bin(servername)
new_order.append('udp')
if settings.enableHTTP() and settings.enableHTTPreceiving():
new_contacts['http'] = b'http://' + strng.to_bin(
ip) + b':' + strng.to_bin(str(settings.getHTTPPort()))
new_order.append('http')
# erase current contacts from my identity
ident.clearContacts()
# add contacts data to the local identity
for proto in new_order:
contact = new_contacts.get(proto, None)
if contact is None:
lg.warn('proto %s was not found in contacts' % proto)
continue
ident.setProtoContact(proto, contact)
# set other info
# ident.certificates = []
ident.setDate(time.strftime('%b %d, %Y'))
ident.setPostage(1)
ident.setRevision(0)
ident.setVersion('') # TODO: put latest git commit hash here
# update software version number
# version_number = bpio.ReadTextFile(settings.VersionNumberFile()).strip()
# repo, location = misc.ReadRepoLocation()
# ident.version = (version_number.strip() + ' ' + repo.strip() + ' ' + bpio.osinfo().strip()).strip()
# build a version info
# vernum = bpio.ReadTextFile(settings.VersionNumberFile())
# repo, location = misc.ReadRepoLocation()
# ident.version = (vernum.strip() + ' ' + repo.strip() + ' ' + bpio.osinfo().strip()).strip()
# put my public key in my identity
ident.setPublicKey(key.MyPublicKey())
# generate signature
ident.sign()
# validate new identity
if not ident.Valid():
lg.warn('generated identity is not valid !!!')
return ident
def _push(self):
from transport import gateway
if self.route:
# if this packet is routed - send directly to route host
gateway.send_file(
strng.to_bin(self.route['remoteid']),
strng.to_text(self.route['proto']),
strng.to_bin(self.route['host']),
self.filename,
self.description,
self,
)
self.items.append(
WorkItem(strng.to_text(self.route['proto']),
strng.to_bin(self.route['host']), self.filesize))
self.automat('items-sent')
return
# get info about his local IP
localIP = identitycache.GetLocalIP(self.remote_idurl)
workitem_sent = False
if self.wide:
# send to all his contacts
for contactmethod in self.remote_identity.getContacts():
proto, host = nameurl.IdContactSplit(contactmethod)
if host.strip() and \
settings.transportIsEnabled(proto) and \
settings.transportSendingIsEnabled(proto) and \
gateway.can_send(proto) and \
gateway.is_installed(proto):
if proto == 'tcp' and localIP:
host = localIP
gateway.send_file(
strng.to_bin(self.remote_idurl),
strng.to_text(proto),
strng.to_bin(host),
self.filename,
self.description,
self,
)
self.items.append(
WorkItem(strng.to_text(proto), strng.to_bin(host),
self.filesize))
workitem_sent = True
if not workitem_sent:
self.automat('nothing-to-send')
lg.warn('(wide) no supported protocols with %s' %
self.remote_idurl)
else:
self.automat('items-sent')
return
# send to one of his contacts,
# now need to decide which transport to use
# let's prepare his contacts first
byproto = self.remote_identity.getContactsByProto()
tcp_contact = None
if settings.enableTCP() and settings.enableTCPsending():
tcp_contact = byproto.get('tcp', None)
udp_contact = None
if settings.enableUDP() and settings.enableUDPsending():
udp_contact = byproto.get('udp', None)
http_contact = None
if settings.enableHTTP() and settings.enableHTTPsending():
http_contact = byproto.get('http', None)
proxy_contact = None
if settings.enablePROXY() and settings.enablePROXYsending():
proxy_contact = byproto.get('proxy', None)
working_protos = p2p_stats.peers_protos().get(self.remote_idurl, set())
# tcp seems to be the most stable proto
# now let's check if we know his local IP and
# he enabled tcp in his settings to be able to receive packets from others
# try to send to his local IP first, not external
if tcp_contact and localIP:
if gateway.is_installed('tcp') and gateway.can_send(proto):
proto, host, port, fn = nameurl.UrlParse(tcp_contact)
if port:
host = localIP + ':' + str(port)
gateway.send_file(strng.to_bin(self.remote_idurl),
strng.to_text(proto), strng.to_bin(host),
self.filename, self.description, self)
self.items.append(
WorkItem(strng.to_text(proto), strng.to_bin(host),
self.filesize))
self.automat('items-sent')
return
# tcp is the best proto - if it is working - this is the best case!!!
if tcp_contact and 'tcp' in working_protos:
proto, host, port, fn = nameurl.UrlParse(tcp_contact)
if host.strip() and gateway.is_installed(
proto) and gateway.can_send(proto):
if port:
host = host + ':' + str(port)
gateway.send_file(strng.to_bin(self.remote_idurl),
strng.to_text(proto), strng.to_bin(host),
self.filename, self.description)
self.items.append(
WorkItem(strng.to_text(proto), strng.to_bin(host),
self.filesize))
self.automat('items-sent')
return
# udp contact
if udp_contact and 'udp' in working_protos:
proto, host = nameurl.IdContactSplit(udp_contact)
if host.strip() and gateway.is_installed(
'udp') and gateway.can_send(proto):
gateway.send_file(strng.to_bin(self.remote_idurl),
strng.to_text(proto), strng.to_bin(host),
self.filename, self.description, self)
self.items.append(
WorkItem(strng.to_text(proto), strng.to_bin(host),
self.filesize))
self.automat('items-sent')
return
# http contact
if http_contact and 'http' in working_protos:
proto, host, port, _ = nameurl.UrlParse(http_contact)
if host.strip() and gateway.is_installed(
proto) and gateway.can_send(proto):
if port:
host = host + ':' + str(port)
gateway.send_file(strng.to_bin(self.remote_idurl),
strng.to_text(proto), strng.to_bin(host),
self.filename, self.description, self)
self.items.append(
WorkItem(strng.to_text(proto), strng.to_bin(host),
self.filesize))
self.automat('items-sent')
return
# proxy contact - he may use other node to receive and send packets
if proxy_contact and 'proxy' in working_protos:
proto, host = nameurl.IdContactSplit(proxy_contact)
if host.strip() and gateway.is_installed(
'proxy') and gateway.can_send(proto):
gateway.send_file(strng.to_bin(self.remote_idurl),
strng.to_text(proto), strng.to_bin(host),
self.filename, self.description, self)
self.items.append(
WorkItem(strng.to_text(proto), strng.to_bin(host),
self.filesize))
self.automat('items-sent')
return
# finally use the first proto we supported if we can not find the best preferable method
for contactmethod in self.remote_identity.getContacts():
proto, host, port, fn = nameurl.UrlParse(contactmethod)
if port:
host = host + ':' + str(port)
# if method exist but empty - don't use it
if host.strip():
# try sending with tcp even if it is switched off in the settings
if gateway.is_installed(proto) and gateway.can_send(proto):
if settings.enableTransport(
proto) and settings.transportSendingIsEnabled(
proto):
gateway.send_file(strng.to_bin(self.remote_idurl),
strng.to_text(proto),
strng.to_bin(host), self.filename,
self.description, self)
self.items.append(
WorkItem(strng.to_text(proto), strng.to_bin(host),
self.filesize))
self.automat('items-sent')
return
self.automat('nothing-to-send')
lg.warn('no supported protocols with %s : %s %s %s, byproto:%s' %
(self.remote_idurl, tcp_contact, udp_contact, working_protos,
str(byproto)))
def _push(self):
if self.route:
# if this packet is routed - send directly to route host
gateway.send_file(
self.route["remoteid"], self.route["proto"], self.route["host"], self.filename, self.description
)
self.items.append(WorkItem(self.route["proto"], self.route["host"], self.filesize))
self.automat("items-sent")
return
# get info about his local IP
localIP = identitycache.GetLocalIP(self.remote_idurl)
workitem_sent = False
if self.wide:
# send to all his contacts
for contactmethod in self.remote_identity.getContacts():
proto, host = nameurl.IdContactSplit(contactmethod)
if (
host.strip()
and settings.transportIsEnabled(proto)
and settings.transportSendingIsEnabled(proto)
and gateway.can_send(proto)
and gateway.is_installed(proto)
):
if proto == "tcp" and localIP:
host = localIP
gateway.send_file(self.remote_idurl, proto, host, self.filename, self.description)
self.items.append(WorkItem(proto, host, self.filesize))
workitem_sent = True
if not workitem_sent:
self.automat("nothing-to-send")
lg.warn("(wide) no supported protocols with %s" % self.remote_idurl)
else:
self.automat("items-sent")
return
# send to one of his contacts,
# now need to decide which transport to use
# let's prepare his contacts first
byproto = self.remote_identity.getContactsByProto()
tcp_contact = None
if settings.enableTCP() and settings.enableTCPsending():
tcp_contact = byproto.get("tcp", None)
udp_contact = None
if settings.enableUDP() and settings.enableUDPsending():
udp_contact = byproto.get("udp", None)
proxy_contact = None
if settings.enablePROXY() and settings.enablePROXYsending():
proxy_contact = byproto.get("proxy", None)
working_protos = stats.peers_protos().get(self.remote_idurl, set())
# tcp seems to be the most stable proto
# now let's check if we know his local IP and
# he enabled tcp in his settings to be able to receive packets from others
# try to send to his local IP first, not external
if tcp_contact and localIP:
if gateway.is_installed("tcp") and gateway.can_send(proto):
proto, host, port, fn = nameurl.UrlParse(tcp_contact)
if port:
host = localIP + ":" + str(port)
gateway.send_file(self.remote_idurl, proto, host, self.filename, self.description)
self.items.append(WorkItem(proto, host, self.filesize))
self.automat("items-sent")
return
# tcp is the best proto - if it is working - this is the best case!!!
if tcp_contact and "tcp" in working_protos:
proto, host, port, fn = nameurl.UrlParse(tcp_contact)
if host.strip() and gateway.is_installed(proto) and gateway.can_send(proto):
if port:
host = host + ":" + str(port)
gateway.send_file(self.remote_idurl, proto, host, self.filename, self.description)
self.items.append(WorkItem(proto, host, self.filesize))
self.automat("items-sent")
return
# udp contact
if udp_contact and "udp" in working_protos:
proto, host = nameurl.IdContactSplit(udp_contact)
if host.strip() and gateway.is_installed("udp") and gateway.can_send(proto):
gateway.send_file(self.remote_idurl, proto, host, self.filename, self.description)
self.items.append(WorkItem(proto, host, self.filesize))
self.automat("items-sent")
return
# proxy contact - he may use other node to receive and send packets
if proxy_contact and "proxy" in working_protos:
proto, host = nameurl.IdContactSplit(proxy_contact)
if host.strip() and gateway.is_installed("proxy") and gateway.can_send(proto):
gateway.send_file(self.remote_idurl, proto, host, self.filename, self.description)
self.items.append(WorkItem(proto, host, self.filesize))
self.automat("items-sent")
return
# finally use the first proto we supported if we can not find the best preferable method
for contactmethod in self.remote_identity.getContacts():
proto, host, port, fn = nameurl.UrlParse(contactmethod)
if port:
host = host + ":" + str(port)
# if method exist but empty - don't use it
if host.strip():
# try sending with tcp even if it is switched off in the settings
if gateway.is_installed(proto) and gateway.can_send(proto):
if settings.enableTransport(proto) and settings.transportSendingIsEnabled(proto):
gateway.send_file(self.remote_idurl, proto, host, self.filename, self.description)
self.items.append(WorkItem(proto, host, self.filesize))
self.automat("items-sent")
return
self.automat("nothing-to-send")
lg.warn(
"no supported protocols with %s : %s %s %s, byproto:%s"
% (self.remote_idurl, tcp_contact, udp_contact, working_protos, str(byproto))
)