def setContactPort(self, index, newport):
"""
This is useful when listening port get changed.
"""
protocol, host, port, filename = nameurl.UrlParse(self.contacts[index])
url = nameurl.UrlMake(protocol, host, newport, filename)
self.contacts[index] = url.encode("ascii").strip()
def setContactHost(self, host, index):
"""
This is to set only host part of the contact.
"""
protocol, host_, port, filename = nameurl.UrlParse(self.contacts[index])
url = nameurl.UrlMake(protocol, host, port, filename)
self.contacts[index] = url.encode("ascii").strip()
def setContactHost(self, host, index):
"""
This is to set only host part of the contact.
"""
protocol, _, port, filename = nameurl.UrlParse(self.contacts[index])
url = nameurl.UrlMake(protocol, host, port, filename)
self.contacts[index] = strng.to_bin(url).strip()
def setContactPort(self, index, newport):
"""
This is useful when listening port get changed.
"""
protocol, host, _, filename = nameurl.UrlParse(self.contacts[index])
url = nameurl.UrlMake(protocol, host, newport, filename)
self.contacts[index] = strng.to_bin(url).strip()
def doPingServers(self, arg):
"""
Action method.
"""
lg.out(4, 'id_registrator.doPingServers %d in list' % len(self.discovered_servers))
def _cb(htmlsrc, id_server_host):
lg.out(4, ' RESPONDED: %s' % id_server_host)
if self.preferred_servers and id_server_host in self.preferred_servers:
self.good_servers.insert(0, id_server_host)
else:
self.good_servers.append(id_server_host)
self.discovered_servers.remove(id_server_host)
self.automat('id-server-response', (id_server_host, htmlsrc))
def _eb(err, id_server_host):
lg.out(4, ' FAILED: %s' % id_server_host)
self.discovered_servers.remove(id_server_host)
self.automat('id-server-failed', (id_server_host, err))
for host in self.discovered_servers:
webport, tcpport = known_servers.by_host().get(host,
(settings.IdentityWebPort(), settings.IdentityServerPort()))
if webport == 80:
webport = ''
server_url = nameurl.UrlMake('http', host, webport, '')
d = net_misc.getPageTwisted(server_url, timeout=10)
d.addCallback(_cb, host)
d.addErrback(_eb, host)
def _server_replied(htmlsrc, host, pos):
if _Debug:
lg.out(_DebugLevel, 'id_rotator.doSelectNewIDServer._server_replied %r' % host)
webport, _ = target_servers[host]
if webport == 80:
webport = ''
new_idurl = nameurl.UrlMake('http', strng.to_text(host), webport, my_id.getIDName() + '.xml')
d = net_misc.getPageTwisted(new_idurl, timeout=10)
d.addCallback(_new_idurl_exist, new_idurl, pos)
d.addErrback(_new_idurl_not_exist, new_idurl)
def _ping_one_server(pos):
host = target_hosts[pos]
webport, tcpport = target_servers[host]
if webport == 80:
webport = ''
tcpport = int(tcpport)
server_url = nameurl.UrlMake('http', strng.to_text(host), webport, '')
if _Debug:
lg.out(_DebugLevel, 'id_rotator.doSelectNewIDServer._ping_one_server at %s known tcp port is %d' % (
server_url, tcpport, ))
d = net_misc.getPageTwisted(server_url, timeout=10)
d.addCallback(_server_replied, host, pos)
d.addErrback(_server_failed, host, pos)
def doRequestServers(self, *args, **kwargs):
"""
Action method.
"""
login = bpio.ReadTextFile(settings.UserNameFilename())
def _cb(xmlsrc, idurl, host):
if not xmlsrc:
if self.preferred_servers and host in self.preferred_servers:
if self.preferred_servers[0] == host:
self.free_idurls.insert(0, idurl)
else:
self.free_idurls.insert(1, idurl)
else:
self.free_idurls.append(idurl)
self.registrations.remove(idurl)
self.automat('id-not-exist', idurl)
else:
lg.out(4, ' EXIST: %s' % idurl)
self.registrations.remove(idurl)
self.automat('id-exist', idurl)
def _eb(err, idurl, host):
lg.out(4, ' NOT EXIST: %s' % idurl)
if self.preferred_servers and host in self.preferred_servers:
if self.preferred_servers[0] == host:
self.free_idurls.insert(0, idurl)
else:
self.free_idurls.insert(1, idurl)
else:
self.free_idurls.append(idurl)
self.registrations.remove(idurl)
self.automat('id-not-exist', idurl)
for host in self.good_servers:
webport, tcpport = known_servers.by_host().get(
host,
(settings.IdentityWebPort(), settings.IdentityServerPort()))
if webport == 80:
webport = ''
idurl = nameurl.UrlMake('http', strng.to_text(host), webport,
login + '.xml')
lg.out(4, ' %s' % idurl)
d = net_misc.getPageTwisted(idurl, timeout=7)
d.addCallback(_cb, idurl, host)
d.addErrback(_eb, idurl, host)
self.registrations.append(idurl)
lg.out(
4, 'id_registrator.doRequestServers login=%s registrations=%d' %
(login, len(self.registrations)))
def _fallback_and_ping_my_servers(self):
"""
Just ping all my id servers by sending a HTTP request to the "main page".
"""
my_sources = my_id.getLocalIdentity().getSources(as_originals=True)
id_servers = []
for idurl_bin in my_sources:
proto, host, port, _ = nameurl.UrlParse(idurl_bin)
id_servers.append(nameurl.UrlMake(proto, host, port, ''))
if _Debug:
lg.args(_DebugLevel, id_servers=id_servers)
dl = []
for url in id_servers:
d = net_misc.getPageTwisted(url, timeout=5)
dl.append(d)
d = DeferredList(dl, consumeErrors=True)
d.addCallback(lambda result: self.automat('ping-done', []))
d.addErrback(self._fallback_check_network_connected)
def http_stun(result_defer=None):
from userid import known_servers
identity_servers = known_servers.by_host()
if not identity_servers:
if _Debug:
lg.out(
_DebugLevel,
'stun_client.http_stun SKIP, no known identity servers found'
)
return False
one_host = random.choice(list(identity_servers.keys()))
one_port = identity_servers[one_host][0]
one_url = nameurl.UrlMake('http', one_host, one_port)
if _Debug:
lg.out(_DebugLevel,
'stun_client.http_stun GO with one node : %r' % one_url)
def _check_body(html_response):
ret = {
'result': 'stun-failed',
'type': None,
'ip': None,
'details': [
'unknown client host from response',
],
}
mo = re.search(b'\<\!\-\-CLIENT_HOST\=([\d\.]+):(\d+)\-\-\>',
html_response)
if not mo:
if _Debug:
lg.out(
_DebugLevel,
'stun_client.http_stun FAILED : unknown client host from response'
)
if result_defer:
result_defer.callback(ret)
return None
ret = {
'result': 'stun-success',
'type': 'unknown',
'ip': strng.to_text(mo.group(1)),
'details': [],
}
if _Debug:
lg.out(_DebugLevel, 'stun_client.http_stun SUCCESS : %r' % ret)
if result_defer:
result_defer.callback(ret)
return None
def _request_failed(err):
if _Debug:
lg.out(_DebugLevel, 'stun_client.http_stun FAILED : %r' % err)
ret = {
'result': 'stun-failed',
'type': None,
'ip': None,
'details': [
err.getErrorMessage(),
],
}
if result_defer:
result_defer.callback(ret)
return None
d = net_misc.getPageTwisted(one_url)
d.addCallback(_check_body)
d.addErrback(_request_failed)
return True
def setContactParts(self, index, protocol, host, port, filename):
"""
Set a contact at given position by its 4 parts.
"""
url = nameurl.UrlMake(protocol, host, port, filename)
self.contacts[index] = url.encode("ascii").strip()
def setContactParts(self, index, protocol, host, port, filename):
"""
Set a contact at given position by its 4 parts.
"""
url = nameurl.UrlMake(protocol, host, port, filename)
self.contacts[index] = strng.to_bin(url).strip()
