def main():
global logger, reactor
options, args = _parseCommandLine()
settings = localSettings()
if not options.debug:
sys.stdout = sys.stderr = LogFile(settings)
logger.setLevel(logging.INFO)
else:
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.StreamHandler())
logging.getLogger("nitro.selectreactor").addHandler(logging.StreamHandler())
reactor = SelectReactor()
seedNodes = [(options.dhtnode, options.dhtport)]
service = CSpaceService(seedNodes, settings, reactor)
server = SimpleXMLRPCServer(("localhost", options.xmlport))
reactor.addReadCallback(server, server.handle_request)
server.register_instance(service, allow_dotted_names=True)
xmlrpcport = server.socket.getsockname()[1]
logger.info("rpcserver listenport = %i" % xmlrpcport)
appletport = service.appletServer.listenPort
logger.info("seed nodes = (%s:%i)" % (options.dhtnode, options.dhtport))
_writePID(xmlrpcport, appletport)
service.run()
_deletePID()
logger.info("server stopped.")
class BridgeThread( threading.Thread ) :
def __init__( self ) :
threading.Thread.__init__( self )
self.reactor = SelectReactor()
self.threadQueue = ThreadQueue( self._onMessage, self.reactor )
self.bridges = {}
self.start()
def _onMessage( self, msg ) :
cmd,args = msg[0],msg[1:]
if cmd == 'bridge' :
sock,sslConn = args
bridge = SSLBridge( sock, sslConn, self.reactor )
self.bridges[bridge] = 1
bridge.setCloseCallback( lambda : self._onBridgeClosed(bridge) )
elif cmd == 'clear' :
for b in self.bridges.keys() :
b.shutdown()
self.bridges.clear()
elif cmd == 'stop' :
for b in self.bridges.keys() :
b.shutdown()
self.bridges.clear()
self.reactor.stop()
def _onBridgeClosed( self, bridge ) :
del self.bridges[bridge]
def run( self ) :
self.reactor.run()
def main() :
global reactor, session
reactor = SelectReactor()
profile = getProfile()
session = UserSession( profile, reactor )
session.setCloseCallback( onClose )
reactor.callLater( 1, doOnline )
reactor.run()
def main() :
logging.getLogger().addHandler( logging.StreamHandler() )
port = int(os.environ['CSPACE_PORT'])
event = os.environ['CSPACE_EVENT']
assert event == 'CONTACTACTION'
name = os.environ['CSPACE_CONTACTNAME']
showLocation( name, ('127.0.0.1',port) )
reactor = SelectReactor()
reactor.run()
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
class BridgeThread( threading.Thread ) :
def __init__( self ) :
threading.Thread.__init__( self )
self.setDaemon( True )
self.reactor = SelectReactor()
self.threadQueue = ThreadQueue( self._onMessage, self.reactor )
self.start()
def _onMessage( self, msg ) :
sock1,sock2,notifytq = msg
bridge = TCPBridge( sock1, sock2, self.reactor )
bridge.setCloseCallback( lambda : notifytq.postMessage(True) )
def run( self ) :
self.reactor.run()
class BridgeThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.setDaemon(True)
self.reactor = SelectReactor()
self.threadQueue = ThreadQueue(self._onMessage, self.reactor)
self.start()
def _onMessage(self, msg):
sock1, sock2, notifytq = msg
bridge = TCPBridge(sock1, sock2, self.reactor)
bridge.setCloseCallback(lambda: notifytq.postMessage(True))
def run(self):
self.reactor.run()
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 main() :
logging.getLogger().addHandler( logging.StreamHandler() )
if len(sys.argv) == 2 :
initialPort = int(sys.argv[1])
assert checkPort( port )
else : initialPort = 12345
reactor = SelectReactor()
seedNodeAddr = ('127.0.0.1',initialPort)
seedNode = startNode( reactor, seedNodeAddr, [] )
numNodes = 50
for i in range(1,numNodes) :
port = initialPort + i
nodeAddr = ('127.0.0.1',port)
node = startNode( reactor, nodeAddr, [seedNodeAddr] )
print 'started %d nodes' % numNodes
reactor.run()
print '_requestCount =', _requestCount
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 main():
global reactor, session
reactor = SelectReactor()
profile = getProfile()
session = UserSession(profile, reactor)
session.setCloseCallback(onClose)
reactor.callLater(1, doOnline)
reactor.run()
def main():
import sys, logging
from nitro.selectreactor import SelectReactor
logging.getLogger().addHandler(logging.StreamHandler())
args = sys.argv[1:]
if args:
ipAddr = args.pop(0)
else:
ipAddr = '127.0.0.1'
reactor = SelectReactor()
knownNodes = []
for nodeAddr in args:
try:
ip, port = nodeAddr.split(':')
port = int(port)
except TypeError, ValueError:
print 'invalid nodeaddr: %s' % nodeAddr
return
knownNodes.append((ip, port))
def post(self, url, postData, callback=None):
self.c.setopt(pycurl.POST, 1)
self.c.setopt(pycurl.POSTFIELDS, postData)
self.c.setopt(pycurl.POSTFIELDSIZE, len(postData))
hasExpect = False
for h in self.headers:
if h.startswith('Expect:'): hasExpect = True
if not hasExpect:
self.addHeader('Expect:')
return self._request(url, callback)
if __name__ == '__main__':
import sys, logging
logging.getLogger().addHandler(logging.StreamHandler())
from nitro.selectreactor import SelectReactor
reactor = SelectReactor()
url = sys.argv[1]
def onHttpGet(returnCode, data):
print 'returnCode = %d' % returnCode
if data is not None:
print 'len(data) = %d' % len(data)
sys.stdout.write(data)
sys.stdout.flush()
reactor.stop()
HttpRequest(reactor).get(url, onHttpGet)
reactor.run()
def __init__( self ) :
threading.Thread.__init__( self )
self.reactor = SelectReactor()
self.threadQueue = ThreadQueue( self._onMessage, self.reactor )
self.bridges = {}
self.start()
def __init__(self):
threading.Thread.__init__(self)
self.setDaemon(True)
self.reactor = SelectReactor()
self.threadQueue = ThreadQueue(self._onMessage, self.reactor)
self.start()
def __init__( self ) :
threading.Thread.__init__( self )
self.setDaemon( True )
self.reactor = SelectReactor()
self.threadQueue = ThreadQueue( self._onMessage, self.reactor )
self.start()
class TestClient( object ) :
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 _initCount( self ) :
self.startRequestCount = _requestCount
def _getCount( self ) :
return _requestCount - self.startRequestCount
def _doneCount( self ) :
count = self._getCount()
print 'request count =', count
def _onResult( self, err, payload ) :
print 'err=%d, payload=%s' % (err,str(payload))
self._doneCount()
self.reactor.stop()
def _initCount( self ) :
self.startRequestCount = _requestCount
def Ping( self ) :
self._initCount()
self.client.callPing( self.nodeAddr, self._onResult )
self.reactor.run()
def GetAddr( self ) :
self._initCount()
self.client.callGetAddr( self.nodeAddr, self._onResult )
self.reactor.run()
def GetKey( self, publicKey ) :
self._initCount()
self.client.callGetKey( publicKey.toDER_PublicKey(),
self.nodeAddr, self._onResult )
self.reactor.run()
def PutKey( self, rsaKey, data, updateLevel ) :
self._initCount()
signature = computeSignature( rsaKey, data, updateLevel )
self.client.callPutKey( rsaKey.toDER_PublicKey(), data,
updateLevel, signature, self.nodeAddr,
self._onResult )
self.reactor.run()
def FindNodes( self, destId ) :
self._initCount()
self.client.callFindNodes( destId, self.nodeAddr, self._onResult )
self.reactor.run()
def Lookup( self, destId ) :
def onResult( result ) :
print 'result = %s' % str(result)
self._doneCount()
self.reactor.stop()
self._initCount()
self.client.lookup( destId, [self.nodeAddr], onResult )
self.reactor.run()
def LookupGetKey( self, publicKey ) :
def onResult( result ) :
print 'result = %s' % str(result)
self._doneCount()
self.reactor.stop()
self._initCount()
self.client.lookupGetKey( publicKey, [self.nodeAddr], onResult )
self.reactor.run()
def LookupPutKey( self, rsaKey, data, updateLevel ) :
def onResult( successCount, latestUpdateLevel ) :
print 'successCount=%d, latestUpdateLevel=%d' % (
successCount, latestUpdateLevel)
self._doneCount()
self.reactor.stop()
self._initCount()
self.client.lookupPutKey( rsaKey, data, updateLevel,
[self.nodeAddr], onResult )
self.reactor.run()
def imain():
global reactor, nodeClient, nodeAddr
reactor = SelectReactor()
nodeAddr = ('127.0.0.1', 13542)
nodeClient = NodeClient(reactor)
nodeClient.setCloseCallback(onClose)
class TestClient(object):
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 _initCount(self):
self.startRequestCount = _requestCount
def _getCount(self):
return _requestCount - self.startRequestCount
def _doneCount(self):
count = self._getCount()
print 'request count =', count
def _onResult(self, err, payload):
print 'err=%d, payload=%s' % (err, str(payload))
self._doneCount()
self.reactor.stop()
def _initCount(self):
self.startRequestCount = _requestCount
def Ping(self):
self._initCount()
self.client.callPing(self.nodeAddr, self._onResult)
self.reactor.run()
def GetAddr(self):
self._initCount()
self.client.callGetAddr(self.nodeAddr, self._onResult)
self.reactor.run()
def GetKey(self, publicKey):
self._initCount()
self.client.callGetKey(publicKey.toDER_PublicKey(), self.nodeAddr,
self._onResult)
self.reactor.run()
def PutKey(self, rsaKey, data, updateLevel):
self._initCount()
signature = computeSignature(rsaKey, data, updateLevel)
self.client.callPutKey(rsaKey.toDER_PublicKey(), data, updateLevel,
signature, self.nodeAddr, self._onResult)
self.reactor.run()
def FindNodes(self, destId):
self._initCount()
self.client.callFindNodes(destId, self.nodeAddr, self._onResult)
self.reactor.run()
def Lookup(self, destId):
def onResult(result):
print 'result = %s' % str(result)
self._doneCount()
self.reactor.stop()
self._initCount()
self.client.lookup(destId, [self.nodeAddr], onResult)
self.reactor.run()
def LookupGetKey(self, publicKey):
def onResult(result):
print 'result = %s' % str(result)
self._doneCount()
self.reactor.stop()
self._initCount()
self.client.lookupGetKey(publicKey, [self.nodeAddr], onResult)
self.reactor.run()
def LookupPutKey(self, rsaKey, data, updateLevel):
def onResult(successCount, latestUpdateLevel):
print 'successCount=%d, latestUpdateLevel=%d' % (successCount,
latestUpdateLevel)
self._doneCount()
self.reactor.stop()
self._initCount()
self.client.lookupPutKey(rsaKey, data, updateLevel, [self.nodeAddr],
onResult)
self.reactor.run()
import logging
logging.getLogger().addHandler(logging.StreamHandler())
from time import time
from nitro.selectreactor import SelectReactor
from nitro.tcp import TCPStream
from cspace.node.client import NodeClient
reactor = SelectReactor()
nodeAddr = ('127.0.0.1', 13542)
nodeClient = None
class EchoClient(object):
def __init__(self, sock, reactor):
self.sock = sock
self.reactor = reactor
self.stream = TCPStream(self.sock, self.reactor)
self.stream.setCloseCallback(self._onClose)
self.stream.setErrorCallback(self._onError)
self.stream.setInputCallback(self._onInput)
self.timerOp = self.reactor.addTimer(1, self._onTimer)
self.stream.initiateRead(8192)
def _shutdown(self):
self.stream.shutdown()
self.sock.close()
self.timerOp.cancel()
self.reactor.stop()
def get( self, url, callback=None ) :
return self._request( url, callback )
def post( self, url, postData, callback=None ) :
self.c.setopt( pycurl.POST, 1 )
self.c.setopt( pycurl.POSTFIELDS, postData )
self.c.setopt( pycurl.POSTFIELDSIZE, len(postData) )
hasExpect = False
for h in self.headers :
if h.startswith('Expect:') : hasExpect = True
if not hasExpect :
self.addHeader( 'Expect:' )
return self._request( url, callback )
if __name__ == '__main__' :
import sys, logging
logging.getLogger().addHandler( logging.StreamHandler() )
from nitro.selectreactor import SelectReactor
reactor = SelectReactor()
url = sys.argv[1]
def onHttpGet( returnCode, data ) :
print 'returnCode = %d' % returnCode
if data is not None :
print 'len(data) = %d' % len(data)
sys.stdout.write( data )
sys.stdout.flush()
reactor.stop()
HttpRequest( reactor ).get( url, onHttpGet )
reactor.run()
