def main():
from solipsis.core.event import EventFactory
from solipsis.core.peerevent import PeerEventFactory
from solipsis.core.controlevent import ControlEventFactory
from solipsis.util.parameter import Parameters
from solipsis.core.node import Node
configFileName = searchPath + '/conf/solipsis.conf'
params = Parameters(configFileName)
node = Node(params)
EventFactory.init(node)
f1 = PeerEventFactory()
f2 = ControlEventFactory()
EventFactory.register(PeerEventFactory.TYPE, f1)
EventFactory.register(ControlEventFactory.TYPE, f2)
f3 = EventFactory.getInstance(PeerEventFactory.TYPE)
best = f3.createBEST()
f4 = EventFactory.getInstance(ControlEventFactory.TYPE)
dead = f4.createDEAD(54)
print best
print dead
return 0
def TIMER(self, event):
manager = self.node.getPeersManager()
nbSeeds = len(self.portList)
nbPeers = manager.getNumberOfPeers()
# we have connected to all other seeds
if nbPeers == nbSeeds -1 :
self.logger.debug('Entering Idle state')
ar = manager.computeAwarenessRadius()
self.node.setAwarenessRadius(ar)
self.node.setExpectedPeers(nbPeers)
self.node.startPeriodicTasks()
self.sendUpdate()
self.node.setState(state.Idle())
else:
self.logger.debug('Not connected to all seeds: %d/%d', nbPeers,
nbSeeds -1)
# relaunch timer
self.startTimer()
connectedPorts = []
for peer in manager.enumeratePeers():
connectedPorts.append(peer.getAddress().getPort())
#self.logger.debug('ports: %s' , str(connectedPorts))
for port in self.portList:
if (port <> self.node.getAddress().getPort()) and \
( port not in connectedPorts):
f = EventFactory.getInstance(PeerEvent.TYPE)
hello = f.createHELLO()
hello.setRecipientAddress(Address(self.node.host, port))
self.node.dispatch(hello)
def addService(self, srvId, srvDesc, srvConnectionString):
""" add a new service to the node. """
factory = EventFactory.getInstance(ControlEvent.TYPE)
addSrv = factory.createADDSERVICE(srvId, srvDesc, srvConnectionString)
self.incoming.put(addSrv)
return self.ok
def disconnect(self):
""" Disconnect node
Return OK """
factory = EventFactory.getInstance(ControlEvent.TYPE)
controlEvent = factory.createDISCONNECT
self.incoming.put(controlEvent)
return self.ok
def getNodeInfo(self):
""" Return all the caracteristics of the node
[id, positionX, positionY, AR, CA, pseudo, orientation ]
"""
factory = EventFactory.getInstance(ControlEvent.TYPE)
controlEvent = factory.createGETNODEINFO()
self.incoming.put(controlEvent)
return self.ok
def delService(self, srvId):
""" Remove a service
srvId : id of the service to remove
Return : OK """
factory = EventFactory.getInstance(ControlEvent.TYPE)
rmSrv = factory.createDELSERVICE(srvId)
self.incoming.put(rmSrv)
return self.ok
def getPeerInfo(self, id):
""" Return all the caracteristics of a peer
[id, positionX, positionY, AR, CA, pseudo, orientation ]
id : id of the peer
"""
factory = EventFactory.getInstance(ControlEvent.TYPE)
controlEvent = factory.createGETPEERINFO(id)
self.incoming.put(controlEvent)
return self.ok
def jump(self, x, y, z):
""" Reception of a jump order
x,y,z : target coordinates. These parameters are passed as string
to avoid int overflow problems
"""
pos = Position(long(x), long(y), long(z))
factory = EventFactory.getInstance(ControlEvent.TYPE)
jump = factory.createJUMP(pos)
self.incoming.put(jump)
return self.ok
def run(self):
""" Receive messages from other nodes and process them.
Send messages to other nodes.
"""
try:
try:
self.socket.bind((self.host, self.port))
self.socket.setblocking(0)
self.logger.debug("UDP connector started:" + str(self.socket.getsockname()))
while not self.stopThread:
data = ""
# send outgoing messages
if not self.outgoing.empty():
e = self.outgoing.get()
self._send_no_wait(e)
readsock, writesock, errsock = select.select([self.socket], [], [], 2)
if len(readsock):
try:
# receive and process message from other nodes
data, sender = self.socket.recvfrom(self.BUFFER_SIZE)
if len(data) > 0:
self.logger.debug("recvfrom %s:%s: %s", sender[0],
sender[1],data)
# Parse data and create a new event
netEvent = self.parser.createEvent(data)
# store ip address and port of sender
netEvent.setSenderAddress(Address(sender[0], sender[1]))
# add a new event to the queue of events that need to be
# processed
self.incoming.put(netEvent)
except ValueError:
self.logger.warn("NetThread - parsing error - unknown message " + data)
except:
self.logger.debug("Exception in network thread - " +
str(sys.exc_info()[0]))
raise
except Exception, e:
evt = EventFactory.getInstance(ControlEvent.TYPE).createABORT('UDP connector error-' +
str(e))
self.incoming.put(evt)
raise
finally:
self.socket.close()
self.logger.info('End of Network Server...')
sys.exit(0)
def kill(self):
""" Kill the node and stop connection betwwen navigator and node
"""
# send a KILL order to the node
factory = EventFactory.getInstance(ControlEvent.TYPE)
kill = factory.createKILL()
self.incoming.put(kill)
# stop this connector
self.connector.stop()
return self.ok
def setUp(self):
configFileName = "../../conf/solipsis.conf"
configFileName = "../../conf/solipsis.conf"
parser = OptionParser('')
param = Parameters(parser, configFileName)
self.node = Node(param)
EventFactory.init(self.node)
EventFactory.register(PeerEventFactory.TYPE, PeerEventFactory())
EventFactory.register(ControlEventFactory.TYPE, ControlEventFactory())
def testCreateEvent(self):
pf = EventFactory.getInstance(PeerEvent.TYPE)
evt = pf.createHELLO()
print evt.__dict__
print '\n'
n = Notification()
n.setFromEvent(evt)
print n.__dict__
print '\n'
e= n.createEvent()
print e.__dict__
print '\n'
e2 = pf.createHEARTBEAT()
parser = PeerEventParser()
print parser.getData(e2)
