def connect_to(host, keep_alive=True):
"""
"""
host = net_misc.normalize_address(host)
if host in started_connections():
lg.warn('already connecting to "%s"' % host)
return False
for peeraddr, connections in opened_connections().items():
if peeraddr == host:
lg.warn('already connected to "%s" with %d connections' %
(host, len(connections)))
return True
for connection in connections:
if connection.getConnectionAddress():
if connection.getConnectionAddress() == host:
lg.warn(
'already connected to "%s" with peer address: "%s"' %
(host, peeraddr))
return True
if _Debug:
lg.out(_DebugLevel,
'tcp_node.connect_to "%s", keep_alive=%s' % (host, keep_alive))
connection = TCPFactory(host, keep_alive=keep_alive)
started_connections()[host] = connection
connection.connector = reactor.connectTCP(
host[0], host[1], connection,
timeout=_ConnectionTimeout) # @UndefinedVariable
return False
def send(filename, remoteaddress, description=None, keep_alive=True):
"""
"""
remoteaddress = net_misc.normalize_address(remoteaddress)
result_defer = Deferred()
if remoteaddress in started_connections():
started_connections()[remoteaddress].add_outbox_file(
filename, description, result_defer, keep_alive)
if not keep_alive:
if _Debug:
lg.out(
_DebugLevel,
'tcp_node.send single, use started connection to %s, %d already started and %d opened'
% (str(remoteaddress), len(
started_connections()), len(opened_connections())))
return result_defer
for peeraddr, connections in opened_connections().items():
for connection in connections:
if peeraddr == remoteaddress:
connection.append_outbox_file(filename, description,
result_defer, keep_alive)
if not keep_alive:
if _Debug:
lg.out(
_DebugLevel,
'tcp_node.send single, use opened connection to %s, %d already started and %d opened'
% (str(remoteaddress), len(started_connections()),
len(opened_connections())))
return result_defer
if connection.getConnectionAddress():
if connection.getConnectionAddress() == remoteaddress:
connection.append_outbox_file(filename, description,
result_defer, keep_alive)
if not keep_alive:
if _Debug:
lg.out(
_DebugLevel,
'tcp_node.send single, use opened connection to %s, %d already started and %d opened'
% (str(remoteaddress),
len(started_connections()),
len(opened_connections())))
return result_defer
if _Debug:
lg.out(_DebugLevel,
'tcp_node.send start connecting to "%s"' % str(remoteaddress))
connection = TCPFactory(remoteaddress, keep_alive=keep_alive)
started_connections()[remoteaddress] = connection
connection.add_outbox_file(filename, description, result_defer, keep_alive)
connection.connector = reactor.connectTCP(remoteaddress[0],
remoteaddress[1],
connection,
timeout=_ConnectionTimeout)
if not keep_alive:
if _Debug:
lg.out(
_DebugLevel,
'tcp_node.send opened a single connection to %s, %d already started and %d opened'
% (str(remoteaddress), len(
started_connections()), len(opened_connections())))
return result_defer
def my_host(normalize=False):
global _MyHost
if not _MyHost:
return None
if normalize:
return net_misc.normalize_address(_MyHost)
return _MyHost
def send_file_single(self, remote_idurl, filename, host, description=''):
"""
"""
return tcp_node.send(filename,
net_misc.normalize_address(host),
description,
keep_alive=False)
def SendServers():
"""
My identity file can be stored in different locations, see the "sources"
field.
So I can use different identity servers to store more secure and reliable. This
method will send my identity file to all my identity servers via
transport_tcp.
"""
from transport.tcp import tcp_node
sendfile, sendfilename = tmpfile.make("propagate")
os.close(sendfile)
LocalIdentity = my_id.getLocalIdentity()
bpio.WriteTextFile(sendfilename, LocalIdentity.serialize(as_text=True))
dlist = []
for idurl in LocalIdentity.getSources(as_originals=True):
# sources for out identity are servers we need to send to
protocol, host, port, filename = nameurl.UrlParse(idurl)
# TODO: rebuild identity-server logic to be able to send my identity via HTTP POST instead of TCP and
# get rid of second TCP port at all
webport, tcpport = known_servers.by_host().get(host, (
# by default use "expected" port numbers
settings.IdentityWebPort(), settings.IdentityServerPort()))
normalized_address = net_misc.normalize_address((host, int(tcpport), ))
dlist.append(tcp_node.send(
sendfilename, normalized_address, 'Identity', keep_alive=False,
))
if _Debug:
lg.args(_DebugLevel, normalized_address=normalized_address, filename=filename)
dl = DeferredList(dlist, consumeErrors=True)
return dl
def main():
lg.set_debug_level(24)
if len(sys.argv) >= 4 and sys.argv[1] == 'connect':
tcp_node.connect_to(
net_misc.normalize_address((sys.argv[2], int(sys.argv[3]))))
reactor.run()
return
if len(sys.argv) >= 5 and sys.argv[1] == 'send':
tcp_node.send(
sys.argv[2],
net_misc.normalize_address((sys.argv[3], int(sys.argv[4]))))
reactor.run()
return
print('Usage:')
print('tcp_node.py <command> <arguments>')
print('')
print('Commands:')
print(' connect host port')
print(' send filename host port')
print('')
def disconnect_from(host):
"""
"""
host = net_misc.normalize_address(host)
ok = False
for peeraddr, connections in opened_connections().items():
alll = False
if peeraddr == host:
alll = True
for connection in connections:
if alll:
connection.automat('disconnect')
ok = True
continue
if connection.getConnectionAddress():
if connection.getConnectionAddress() == host:
connection.automat('disconnect')
return True
return ok
def find_session(self, host=None, idurl=None):
"""
"""
if idurl:
for opened_connection in tcp_node.opened_connections().values():
for channel in opened_connection:
if channel.get_idurl() and channel.get_idurl() == idurl:
if _Debug:
lg.dbg(_DebugLevel,
'found active connection for %r' % idurl)
return [
channel,
]
return []
search_for_host = net_misc.normalize_address(host)
if _Debug:
lg.dbg(
_DebugLevel, 'looking for %r, known connections: %r' % (
search_for_host,
list(tcp_node.opened_connections().keys()),
))
return tcp_node.opened_connections().get(search_for_host, [])
def cancel_outbox_file(host, filename):
"""
"""
host = net_misc.normalize_address(host)
if _Debug:
lg.args(_DebugLevel, host=host, filename=filename)
from transport.tcp import tcp_interface
for connections in opened_connections().values():
for connection in connections:
if connection.peer_address and connection.peer_address == host or \
connection.peer_external_address and connection.peer_external_address == host:
i = 0
while i < len(connection.outboxQueue):
fn, description, result_defer, keep_alive = connection.outboxQueue[
i]
if fn == filename:
connection.outboxQueue.pop(i)
connection.failed_outbox_queue_item(
fn, description, 'cancelled')
continue
i += 1
for connection in started_connections().values():
if connection.connection_address and connection.connection_address == host:
i = 0
while i < len(connection.pendingoutboxfiles):
fn, description, result_defer, keep_alive = connection.pendingoutboxfiles[
i]
if fn == filename:
connection.pendingoutboxfiles.pop(i)
try:
tcp_interface.interface_cancelled_file_sending(
host, filename, 0, description, 'cancelled')
except Exception as exc:
lg.warn(str(exc))
if result_defer:
result_defer.callback(
(filename, description, 'failed', 'cancelled'))
continue
i += 1
def SendServers():
"""
My identity file can be stored in different locations, see the "sources"
field.
So I can use different identity servers to store more secure. This
method will send my identity file to all my identity servers via
transport_tcp.
"""
from transport.tcp import tcp_node
sendfile, sendfilename = tmpfile.make("propagate")
os.close(sendfile)
LocalIdentity = my_id.getLocalIdentity()
bpio.WriteTextFile(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)
# if host == settings.IdentityServerName():
# host = '67.207.147.183'
webport, tcpport = known_servers.by_host().get(
host, (settings.IdentityWebPort(), settings.IdentityServerPort()))
# srvhost = '%s:%d' % (host, int(tcpport))
dlist.append(
tcp_node.send(
sendfilename,
net_misc.normalize_address((
host,
int(tcpport),
)),
'Identity',
keep_alive=False,
))
# dlist.append(gateway.send_file_single('tcp', srvhost, sendfilename, 'Identity'))
dl = DeferredList(dlist, consumeErrors=True)
return dl
def find_session(self, host):
"""
"""
return tcp_node.opened_connections().get(
net_misc.normalize_address(host), [])
def cancel_outbox_file(self, host, filename):
"""
"""
return tcp_node.cancel_outbox_file(net_misc.normalize_address(host),
filename)
def disconnect_from(self, host):
"""
"""
return tcp_node.disconnect_from(net_misc.normalize_address(host))
def connect_to(self, host):
"""
"""
return tcp_node.connect_to(net_misc.normalize_address(host))
def send_keep_alive(self, host):
"""
"""
return tcp_node.send_keep_alive(net_misc.normalize_address(host))
def getTransportAddress(self):
peer = self.transport.getPeer()
return net_misc.normalize_address((
peer.host,
int(peer.port),
))
def getConnectionAddress(self):
return net_misc.normalize_address(self.factory.connection_address)
def getAddress(self):
addr = self.getConnectionAddress()
if not addr:
addr = self.getTransportAddress()
return net_misc.normalize_address(addr)
