def __init__(self, nodeAddr):
self.nodeAddr = nodeAddr
self.sock = socket(AF_INET, SOCK_DGRAM)
self.sock.bind(('', 0))
self.reactor = SelectReactor()
self.rpcSocket = RPCSocket(self.sock, self.reactor)
self.client = DHTClient(self.rpcSocket)
self.client.timeout = 1.5
self.client.retries = 1
self.client.backoff = 1
def getLocation( publicKey ) :
reactor = SelectReactor()
udpSock = socket.socket( socket.AF_INET, socket.SOCK_DGRAM )
udpSock.bind( ('',0) )
rpcSocket = RPCSocket( udpSock, reactor )
dhtClient = DHTClient( rpcSocket )
nodeAddr = ('210.210.1.102',10001)
nodeTable = NodeTable( [nodeAddr] )
locList = []
def onLookup( location ) :
locList.append( location )
reactor.stop()
lookupUser( publicKey, dhtClient, nodeTable, onLookup )
reactor.run()
rpcSocket.close()
return locList[0]
def __init__(self, rpcSocket, reactor, knownNodes=[]):
self.rpcSocket = rpcSocket
self.reactor = reactor
self.rpcSocket.setRequestCallback(self._onInput)
self.store = DataStore()
self.ktable = KTable(idToNum(addrToId(rpcSocket.getAddr())))
self.ktracker = KTracker(self.ktable)
for nodeAddr in knownNodes:
self.ktable.nodeSeen(nodeAddr)
self.client = DHTClient(rpcSocket, False, self.ktracker)
self.requestTable = {}
for x in MESSAGES:
self.requestTable[x] = getattr(self, 'do%s' % x)
self.otherOps = set()
self._initNodeRefresher()
self._initDataTimer()
def _testFirewall(tcpListener,
rpcSock,
nodeAddrList,
localIP,
reactor,
callback=None):
def doCancel():
for checkOp in checkOps:
checkOp.cancel()
checkOps.clear()
testServer.close()
def onCheck(checkOp, err, payload):
checkOps.remove(checkOp)
if err >= 0:
fwResult, fwToken = payload
if (fwResult >= 0) and (fwToken == token):
successList.append(1)
if not checkOps:
testServer.close()
# n(success)/n(nodes) >= 1/2
op.notify(2 * len(successList) >= len(nodeAddrList))
def doCheck(nodeAddr):
checkOp = dhtClient.callFirewallCheck(
localIP, nodeAddr, lambda e, p: onCheck(checkOp, e, p))
checkOps.add(checkOp)
assert nodeAddrList
successList = []
checkOps = set()
token = rand_bytes(20)
dhtClient = DHTClient(rpcSock)
testServer = FirewallTestServer(tcpListener, token, reactor)
for nodeAddr in nodeAddrList:
doCheck(nodeAddr)
op = AsyncOp(callback, doCancel)
return op
def goOnline(self, profile):
assert self.sm.current() == self.OFFLINE
obj = Dummy()
def doCleanup():
if obj.initNodeTableOp is not None:
obj.initNodeTableOp.cancel()
if obj.nodeTableRefresher is not None:
obj.nodeTableRefresher.close()
if obj.listener is not None:
obj.listener.close()
obj.rpcSocket.close()
def onOffline():
#self.nodeRunner.close()
#self.nodeRunner = None
self.listener.close()
self.listener = None
self.permissions = None
self.locationCache.close()
self.locationCache = None
self.nodeTableRefresher.close()
self.nodeTableRefresher = None
_saveNodeCache(self.nodeTable)
self.nodeTable = None
self.dhtClient = None
self.rpcSocket.close()
self.rpcSocket = None
self.profile = None
def onListenerStart(result):
if not result:
self.sm.removeCallback(obj.callbackId)
doCleanup()
self.sm.change(self.OFFLINE)
return
obj.listener.setCloseCallback(self._onListenerClose)
obj.listener.setIncomingCallback(self._onIncoming)
self.profile = profile
self.rpcSocket = obj.rpcSocket
self.dhtClient = obj.dhtClient
self.nodeTable = obj.nodeTable
self.nodeTableRefresher = obj.nodeTableRefresher
self.locationCache = LocationCache(self.dhtClient, self.nodeTable,
self.reactor)
self.listener = obj.listener
self.permissions = Permissions(profile, self.services.keys())
if self.permissions.isModified():
self.permissions.savePermissions()
#self.nodeRunner = NodeRunner( self.nodeTable, self.reactor )
self.sm.removeCallback(obj.callbackId)
self.sm.appendCallback(onOffline, dest=self.OFFLINE, single=True)
self.sm.change(self.ONLINE)
def onNodeTableInit():
obj.initNodeTableOp = None
obj.nodeTableRefresher = NodeTableRefresher(
obj.nodeTable, obj.dhtClient, self.reactor)
updateLevelStore = UpdateLevelStore(profile)
obj.listener = UserListener(profile.name, profile.rsaKey,
updateLevelStore, obj.dhtClient,
obj.nodeTable, self.reactor)
obj.listener.start(onListenerStart)
self.sm.change(self.CONNECTING)
obj.callbackId = self.sm.insertCallback(doCleanup,
src=self.CONNECTING,
single=True)
obj.nodeTable = NodeTable(self.seedNodes)
#_loadNodeCache( obj.nodeTable )
udpSock = socket(AF_INET, SOCK_DGRAM)
udpSock.bind(('', 0))
obj.rpcSocket = RPCSocket(udpSock, self.reactor)
obj.dhtClient = DHTClient(obj.rpcSocket, nodeTracker=obj.nodeTable)
obj.initNodeTableOp = initNodeTable(obj.nodeTable, obj.dhtClient,
self.reactor, onNodeTableInit)
obj.nodeTableRefresher = None
obj.listener = None
