def main():
global _BaseDir
global _Debug
options, args = parseCommandLine()
_BaseDir = options.basedir
_Debug = options.debug
dhnio.init()
dhnio.SetDebug(18)
settings.init()
import identitycache
identitycache.init()
reactor.addSystemEventTrigger('before', 'shutdown', shutdown_final)
# from transport_control import _InitDone
# _InitDone = True
def initDone(state, options, args):
if state != 'online':
print 'state is %s, exit' % state
reactor.stop()
return
if options.send:
# def _random_sending(count):
# import random
# if count > 10:
# return
# print 'sending file %s to %s' % (args[0], args[1])
# reactor.callLater(random.randint(0, 2), _random_sending, count+1)
# send(args[0], args[1])
# count += 1
# reactor.callLater(0.5, _random_sending, 0)
send(args[0], args[1])
return
if options.receive:
print 'state is %s, receiving...' % state
return
print 'ONLINE !!!'
init().addCallback(initDone, options, args)
# reactor.callLater(20, A, 'shutdown')
reactor.run()
def main():
sys.path.append('..')
def _go_stun(port):
print '+++++ LISTEN UDP ON PORT', port, 'AND RUN STUN DISCOVERY'
stun.stunExternalIP(close_listener=False, internal_port=port, verbose=False).addBoth(_stuned)
def _stuned(ip):
if stun.getUDPClient() is None:
print 'UDP CLIENT IS NONE - EXIT'
reactor.stop()
return
print '+++++ EXTERNAL UDP ADDRESS IS', stun.getUDPClient().externalAddress
if sys.argv[1] == 'listen':
print '+++++ START LISTENING'
return
if sys.argv[1] == 'connect':
print '+++++ CONNECTING TO REMOTE MACHINE'
_try2connect()
return
lid = misc.getLocalIdentity()
udp_contact = 'udp://'+stun.getUDPClient().externalAddress[0]+':'+str(stun.getUDPClient().externalAddress[1])
lid.setProtoContact('udp', udp_contact)
lid.sign()
misc.setLocalIdentity(lid)
misc.saveLocalIdentity()
print '+++++ UPDATE IDENTITY', str(lid.contacts)
_send_servers().addBoth(_id_sent)
def _start_sending_ip():
init(stun.getUDPClient())
A().debug = True
reactor.callLater(1, Start)
def _start_session():
# transport_udp_session.SetStateChangedCallbackFunc(_state_changed)
address = (sys.argv[2], int(sys.argv[3]))
sess = transport_udp_session.open_session(address)
filename = sys.argv[4]
loop_delay = None if len(sys.argv)<6 else int(sys.argv[5])
transport_udp_session._StateChangedCallbackFunc = lambda index, old, new: _state_changed(index, address[0], new, filename, loop_delay)
sess.automat('init', None)
reactor.callLater(2, _start_session)
def _state_changed(index, ip, newstate, filename, loop_delay):
print '+++++ STATE CHANGED [%s]' % newstate
sess = automat.objects().get(index)
if newstate == 'CONNECTED':
transport_udp_session.SetStateChangedCallbackFunc(None)
if loop_delay:
reactor.callLater(2, LoopingCall(send, filename, sess.remote_address[0], sess.remote_address[1]).start, loop_delay, True)
else:
reactor.callLater(2, send, filename, sess.remote_address[0], sess.remote_address[1])
def _send_servers():
import tmpfile, misc, nameurl, settings, transport_tcp
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)
print '+++++ IDENTITY SENT TO %s:%s' % (host, port)
return dl
def _try2connect():
remote_addr = dhnio.ReadTextFile(sys.argv[3]).split(' ')
remote_addr = (remote_addr[0], int(remote_addr[1]))
t = int(str(int(time.time()))[-1]) + 1
data = '0' * t
stun.getUDPClient().transport.write(data, remote_addr)
print 'sent %d bytes to %s' % (len(data), str(remote_addr))
reactor.callLater(1, _try2connect)
def _id_sent(x):
print '+++++ ID UPDATED ON THE SERVER', x
if sys.argv[1] == 'send':
_start_sending()
elif sys.argv[1] == 'sendip':
_start_sending_ip()
elif sys.argv[1] == 'receive':
_start_receiving()
def _start_receiving():
idurl = sys.argv[2]
if not idurl.startswith('http://'):
idurl = 'http://'+settings.IdentityServerName()+'/'+idurl+'.xml'
print '+++++ START RECEIVING FROM', idurl
_request_remote_id(idurl).addBoth(_receive_from_remote_peer, idurl)
def _receive_from_remote_peer(x, idurl):
init(stun.getUDPClient())
A().debug = True
contacts.addCorrespondent(idurl)
reactor.callLater(1, Start)
def _start_sending():
idurl = sys.argv[2]
if not idurl.startswith('http://'):
idurl = 'http://'+settings.IdentityServerName()+'/'+idurl+'.xml'
print '+++++ START SENDING TO', idurl
# if len(sys.argv) == 6:
# send(sys.argv[5], sys.argv[3], int(sys.argv[4]))
# elif len(sys.argv) == 4:
_request_remote_id(idurl).addBoth(_send_to_remote_peer, idurl, sys.argv[3], None if len(sys.argv)<5 else int(sys.argv[4]))
def _request_remote_id(idurl):
print '+++++ REQUEST ID FROM SERVER', idurl
return identitycache.immediatelyCaching(idurl)
def _send_to_remote_peer(x, idurl, filename, loop_delay):
print '+++++ PREPARE SENDING TO', idurl
init(stun.getUDPClient())
A().debug = True
contacts.addCorrespondent(idurl)
reactor.callLater(1, Start)
ident = identitycache.FromCache(idurl)
if ident is None:
print '+++++ REMOTE IDENTITY IS NONE'
reactor.stop()
return
x, udphost, udpport, x = ident.getProtoParts('udp')
transport_udp_session.SetStateChangedCallbackFunc(lambda index, old, new: _state_changed(index, udphost, new, filename, loop_delay))
def _send_file(idurl, filename):
ident = identitycache.FromCache(idurl)
if ident is None:
print '+++++ REMOTE IDENTITY IS NONE'
reactor.stop()
x, udphost, udpport, x = ident.getProtoParts('udp')
print '+++++ SENDING TO', udphost, udpport
send(filename, udphost, udpport)
def _test_cancel():
import transport_control as tc
for t in tc.current_transfers():
cancel(t.transfer_id)
reactor.callLater(11, _test_cancel)
# reactor.callLater(10, _test_cancel)
dhnio.SetDebug(14)
dhnio.LifeBegins()
settings.init()
misc.loadLocalIdentity()
# contacts.init()
# contacts.addCorrespondent(idurl)
identitycache.init()
identitycache.SetLocalIPs({'http://identity.datahaven.net/veselin.xml': '192.168.1.3',
'http://identity.datahaven.net/veselin-ubuntu-1024.xml': '192.168.1.100'})
port = int(settings.getUDPPort())
if sys.argv[1] in ['listen', 'connect']:
port = int(sys.argv[2])
_go_stun(port)
