def HandleRequest(self, sRequest, sOrigin):
"""Handle incoming Request
Called by cRPCRequestHandler.Request().
Pass Request to cOwlManager.Distribute() for further spreading.
"""
try:
# create cDOM from ascii-request
domRequest = cDOM.cDOM()
domRequest.ParseString(sRequest)
# create cNetPackage from DOM-request
cRequest = cNetPackage.cRecPackage('')
cRequest.ParseDOM(domRequest)
# set originator ip
cRequest.SetOriginatorIP(sOrigin)
# log incoming Request
pManager.manager.DebugStr('cNetManager '+ __version__ +': Incoming Request from %s:%s.' %(str(cRequest.GetOriginator()[0]), str(cRequest.GetOriginator()[1])), 2)
# pass to cOwlManager
self.cOwlManager.Distribute(cRequest)
except:
# unknown error. log and forget.
# get exception
eType, eValue, eTraceback = sys.exc_info()
# build stacktrace string
tb = ''
for line in traceback.format_tb(eTraceback, 15):
tb = tb + line
pManager.manager.DebugStr('pNetwork '+ __version__ +': Unhandled error in thread HandleRequest(): Type: '+str(eType)+', value: '+str(eValue),2)
pManager.manager.DebugStr('pNetwork '+ __version__ +': Traceback:\n'+str(tb), 3)
def HandleAnswer(self, sAnswer, sOrigin):
"""Handle incoming Answer
Called by cRPCRequestHandler.Answer().
Pass Answer to cOwlManager.Answer().
"""
# log incoming Answer
pManager.manager.DebugStr('cNetManager '+ __version__ +': Incoming Answer...', 1)
try:
# create cDOM from ascii-Ping
domAnswer = cDOM.cDOM()
domAnswer.ParseString(sAnswer)
# create cNetPackage from DOM-answer
cAnswer = cNetPackage.cRecPackage('')
cAnswer.ParseDOM(domAnswer)
# set originator ip
cAnswer.SetOriginatorIP(sOrigin)
# pass on to cOwlManager
self.cOwlManager.Answer(cAnswer)
except:
# unknown error. log and forget.
# get exception
eType, eValue, eTraceback = sys.exc_info()
# build stacktrace string
tb = ''
for line in traceback.format_tb(eTraceback, 15):
tb = tb + line
pManager.manager.DebugStr('pNetwork '+ __version__ +': Unhandled error in thread HandleAnswer(): Type: '+str(eType)+', value: '+str(eValue), 2)
pManager.manager.DebugStr('pNetwork '+ __version__ +': Traceback:\n'+str(tb), 3)
def GetDOM(self):
"""Generate cDOM from internal representation
return - cDOM
"""
# create the dom
dom = cDOM.cDOM()
# create core element: originator, containing ip and port as attributes
elOriginator = dom.CreateElement('originator',
{'ip':str(self.sOrigIP),
'port':str(self.iOrigPort)
},
''
)
# create list containing core element and payload
els = []
els.append(elOriginator)
# create container for payload
elPayload = dom.CreateElementContainer('payload', {}, (self.payload, ))
els.append(elPayload)
# create container: iowl.net
elCont = dom.CreateElementContainer('iowl.net',
{'version':self.sVersion,
'protocol':self.sProtocol,
'id':self.sID,
'type':self.sType,
'ttl':str(self.iTTL)
},
els
)
# save elements in dom
dom.SetRootElement(elCont)
return dom
def SetElement(self, el):
"""Read element into internal representation.
el -- element
<itemset count="74">
<url>http://slashdot.org</url>
...
</itemset>
"""
foo = cDOM.cDOM()
# get ... in <itemset count="45">...</itemset>
dAttrs, lContents = foo.GetElementContainerContent \
(el, 'itemset', ['count'])
iCount = string.atoi(dAttrs['count'])
# list with text and attributes
dAttrs, lUrls = foo.GetElementsContent(lContents, 'url', None)
# Convert list of urls into tuple notation.
for url in lUrls:
tUrl = urlparse.urlparse(url)
self.lUrls.append(tUrl)
self.SetCount(iCount)
def HandlePing(self, sPing, sOrigin):
"""Handle incoming Ping
Called by CRPCRequestHandler.
Parse params-string into DOM
Pass Ping to cOwlManager.Distribute()
Generate Answer-Pong.
Pass Pong to cOwlManager.Answer()
"""
try:
# create cDOM from ascii-Ping
domPing = cDOM.cDOM()
domPing.ParseString(sPing)
# create cNetPackage from DOM-Ping
cPing = cNetPackage.cNetPackage('ping')
cPing.ParseDOM(domPing)
# set originator ip
cPing.SetOriginatorIP(sOrigin)
# log incoming ping
pManager.manager.DebugStr('cNetManager '+ __version__ +': Incoming Ping from %s:%s.' %(str(cPing.GetOriginator()[0]), str(cPing.GetOriginator()[1])), 2)
# pass ping to cOwlManager. If cOwlManager accepts ping, answer with pong
pManager.manager.DebugStr('cNetManager '+ __version__ +': Distributing Ping.', 3)
if self.cOwlManager.Distribute(cPing) == 'okay':
# generate Pong
try:
cPong = self.GeneratePong(cPing)
except:
# Could not generate Pong
pManager.manager.DebugStr('cNetManager '+ __version__ +': Could not generate Pong.', 2)
return
# pass Pong to cOlwManager
pManager.manager.DebugStr('cNetManager '+ __version__ +': Answering with Pong.', 3)
self.cOwlManager.Answer(cPong)
else:
# something was wrong with that Ping...
pass
except:
# unknown error. log and forget.
# get exception
eType, eValue, eTraceback = sys.exc_info()
# build stacktrace string
tb = ''
for line in traceback.format_tb(eTraceback, 15):
tb = tb + line
pManager.manager.DebugStr('pNetwork '+ __version__ +': Unhandled error in thread HandlePing(): Type: '+str(eType)+', value: '+str(eValue), 2)
pManager.manager.DebugStr('pNetwork '+ __version__ +': Traceback:\n'+str(tb), 2)
def GetElement(self):
"""Return elements for storing in a DOM."""
foo = cDOM.cDOM()
lEls = []
for rule in self.lRules:
el = rule.GetElement()
lEls.append(el)
contEl = foo.CreateElementContainer('rules', {}, lEls)
return contEl
def SetElement(self, contEl):
"""Read elements into internal representation.
contEl -- elements
"""
foo = cDOM.cDOM()
dAttrs, lEls = foo.GetElementContainerContent(contEl, 'rules', None)
for el in lEls:
rule = cRule.cRule()
rule.SetElement(el)
self.lRules.append(rule)
def HandlePong(self, sPong, sOrigin):
"""Handle incoming Pong
Called by CRPCRequestHandler.Pong().
Reset LastNetAction-time.
Pass PONG to cOwlManager.Answer().
"""
try:
# reset WatchDog
pManager.manager.ResetWatchdog(self.WatchDogID)
# create cDOM from ascii-Pong
domPong = cDOM.cDOM()
domPong.ParseString(sPong)
# create cNetPackage from DOM-Pong
cPong = cNetPackage.cPong()
cPong.ParseDOM(domPong)
# check if i am the first hop of this pong (answerer ip set to 127.0.0.1)
# -> set answerer ip!
if cPong.GetAnswerer()[0]=='127.0.0.1':
pManager.manager.DebugStr('cNetManager '+ __version__ +': First hop. Setting Answerer IP to %s' % (sOrigin), 3)
cPong.SetAnswererIP(sOrigin)
# set originator ip
cPong.SetOriginatorIP(sOrigin)
# log incoming pong
pManager.manager.DebugStr('cNetManager '+ __version__ +': Incoming Pong from %s:%s' % (str(cPong.GetAnswerer()[0]), str(cPong.GetAnswerer()[1])), 2)
# extract PONG-source and add to own list of owls
self.ExtractPongSource(cPong)
# pass to cOwlManager
pManager.manager.DebugStr('cNetManager '+ __version__ +': Passing Pong to cOwlManager.Answer()', 3)
self.cOwlManager.Answer(cPong)
except:
# unknown error. log and forget.
# get exception
eType, eValue, eTraceback = sys.exc_info()
# build stacktrace string
tb = ''
for line in traceback.format_tb(eTraceback, 15):
tb = tb + line
pManager.manager.DebugStr('pNetwork '+ __version__ +': Unhandled error in thread HandlePong(): Type: '+str(eType)+', value: '+str(eValue), 2)
pManager.manager.DebugStr('pNetwork '+ __version__ +': Traceback:\n'+str(tb), 3)
def GeneratePing():
"""Generate a PING cDOM
a Ping looks like:
<iowl.net version="0.1" id="4711" type="Ping" ttl="12">
<originator ip="192.168.99.2" port="2323"></originator>
</iowl.net>
return -- cDOM containing a PING packet
"""
# create unique id
# id = pManager.manager.GetUniqueNumber()
id = 222222
# get own IP from manager
# ownip = pManager.manager.GetOwnIP()
ownip = '1.2.3.4'
# get ListenPort from cNetServer
# iListenPort = self.cNetServer.GetListenPort()
iListenPort = 2323
# create the dom
domPing = cDOM.cDOM()
# create core element: originator, containing ip and port as attributes
elOriginator = domPing.CreateElement('originator', {'ip':str(ownip), 'port':str(iListenPort)}, 'dummy')
# create list containing core element
els = []
els.append(elOriginator)
# get iOwl-version
# sVersion = str(pManager.manager.GetVersion())
# sVersion = 'Testversion'
sVersion = "0.2"
# create container: iowl.net
elCont = domPing.CreateElementContainer('iowl.net', {'version':sVersion, 'id':str(id), 'type':'Ping', 'ttl':str(4)}, els)
# save elements in dom
domPing.SetRootElement(elCont)
# finished!
return domPing
def test():
manager = cNetManager()
manager.cNetServer.SetListenPort(2323)
manager.iTTL = 10
dummy = cDOM.cDOM()
elReq = dummy.CreateElement('request', {'url':'iowl.berlios.de', 'otherurl':'www.arschlecken.de'}, 'Bitte recommendation liefern!')
elAns = dummy.CreateElement('answer', {'url':'www.wissen.de'}, 'Check das aus!')
re = manager.GenerateRequest(elReq)
print
print re.ToXML()
print
an = manager.GenerateAnswer(elAns,id)
print an.ToXML()
print
print manager.cOwlManager.GetDomInfo(an)
def DecrementDomTTL(self, domObj):
"""Decrement TTL of given domObj
XXX This is really ugly, there is no function available to change an
attribute of a DOM 'on-the-fly', i have to build a new DOM just to
decrement a counter.
oh well...
"""
# get element containing attribute 'ttl' -> root element
root = domObj.GetRootElement()
# get attributes of root element
lAttrs = ['version', 'protocol', 'id', 'type', 'ttl']
dAttrs = domObj.GetAttrs(root, lAttrs)
# get current ttl
iCurTTL = int(dAttrs['ttl'])
if iCurTTL <= 0:
# PANIC!
raise 'TTL zero or below zero prior to decrementing!'
# store all childs of rootnode
dAttr, lChilds = domObj.GetElementContainerContent(root, 'iowl.net', lAttrs)
# generate new dom
newDomObj = cDOM.cDOM()
# generate new rootelement (==Elementcontainer)
newroot = newDomObj.CreateElementContainer('iowl.net',
{'version':dAttrs['version'],
'protocol':dAttrs['protocol'],
'id':dAttrs['id'],
'type':dAttrs['type'],
'ttl':str(iCurTTL -1)
},
lChilds)
# set as rootnode
newDomObj.SetRootElement(newroot)
# return new dom
return newDomObj
def GetElement(self):
"""Return Element for storing in a DOM.
return -- contEl, an element covering all urls
"""
lEls = []
foo = cDOM.cDOM()
sCount = str(self.iCount)
for url in self.lUrls:
sUrl = urlparse.urlunparse(url)
el = foo.CreateElement('url', {}, sUrl)
lEls.append(el)
contEl = foo.CreateElementContainer \
('itemset', {'count': sCount}, lEls)
return contEl
def ReplaceOrigin(self, domObj):
"""Replace origin of DOM with myself
returns new DOM
"""
# Get RootElement
root = domObj.GetRootElement()
# Get Name of RootElement
rootname = domObj.GetName(root)
# get childelements
childs = []
lAttrs = ['version', 'protocol', 'id', 'type', 'ttl']
dAttrs, childs = domObj.GetElementContainerContent(root, rootname, lAttrs)
# search for element named 'originator' in childs
for child in childs:
childname = domObj.GetName(child)
if childname == 'originator':
originator = child
# get attributes of originator
lOriginAttrs = ['ip','port']
dOriginAttrs = domObj.GetAttrs(originator, lOriginAttrs)
ip = dOriginAttrs['ip']
port = dOriginAttrs['port']
# get own IP from manager
ownip = pManager.manager.GetOwnIP()
# ownip = '1.2.3.4'
# get ListenPort from cNetServer
iListenPort = self.cNetManager.cNetServer.GetListenPort()
# create new originator element
newOrig = domObj.CreateElement('originator', {'ip':str(ownip), 'port':str(iListenPort)}, '')
# store all childs of rootnode
dAttr, lChilds = domObj.GetElementContainerContent(root, 'iowl.net', lAttrs)
# search and delete originator in lChilds
for child in lChilds:
if domObj.GetName(child) == 'originator':
lChilds.remove(child)
# add new originator to list
lChilds.append(newOrig)
# generate new dom
newDomObj = cDOM.cDOM()
# generate new rootelement (==Elementcontainer)
newroot = newDomObj.CreateElementContainer('iowl.net',
{'version':dAttrs['version'],
'protocol':dAttrs['protocol'],
'id':dAttrs['id'],
'type':dAttrs['type'],
'ttl':dAttrs['ttl']
},
lChilds)
# set as rootnode
newDomObj.SetRootElement(newroot)
# return new dom
return newDomObj
