def parseAPI(self, handler, apitype, path):
""" parse request/response into a WebEvent. """
#logging.warn(dir(handler))
#logging.warn(dir(handler.request))
#logging.warn(request.arguments)
#logging.warn(request.body)
self.handler = handler
self.request = handler.request
self.query = self.request.query
self.upath = path
self.apitype = apitype
self.userhost = tornado.escape.xhtml_escape(handler.current_user)
if not self.userhost: raise Exception("no current user.")
input = path
self.isweb = True
logging.warn("input is %s" % input)
if not input: raise NoInput(input)
self.txt = fromenc(input.strip(), self.bot.encoding)
self.nick = self.userhost.split("@")[0]
self.auth = fromenc(self.userhost)
self.stripped = stripped(self.auth)
self.channel = stripped(self.userhost)
logging.debug(u'tornado - parsed - %s - %s' % (self.txt, self.userhost))
self.prepare()
return self
def parse(self, response, request):
""" parse request/response into a WebEvent. """
logging.warn("parsing %s" % request.body)
body = getpostdata_gae(request)
logging.warn("body is %s" % body)
data = LazyDict(getjson().loads(body))
self.target = data.target
self.how = data.how
if not self.how:
self.how = "channel"
input = data.cmnd
self.isweb = True
self.origtxt = fromenc(input.strip(), self.bot.encoding)
self.txt = self.origtxt
self.usercmnd = self.txt and self.txt.split()[0]
self.groupchat = False
self.response = response
self.request = request
(userhost, user, u, nick) = checkuser(response, request, self)
self.userhost = fromenc(userhost)
self.nick = fromenc(nick)
self.auth = fromenc(userhost)
self.stripped = stripped(self.auth)
self.domain = None
self.channel = stripped(userhost)
logging.debug(u"web - parsed - %s - %s" % (self.txt, self.userhost))
self.makeargs()
return self
def parse(self, handler, request, path=None):
""" parse request/response into a WebEvent. """
self.handler = handler
self.request = request
self.userhost = tornado.escape.xhtml_escape(handler.current_user)
if not self.userhost: raise Exception("no current user.")
try: how = request.arguments['how'][0]
except KeyError: how = "background"
if not how: how = "background"
self.how = how
if self.how == "undefined": self.how = "overwrite"
logging.warn("web - how is %s" % self.how)
input = request.headers.get('content') or request.headers.get('cmnd')
if not input:
try: input = request.arguments['content'] or request.arguments['cmnd']
except KeyError: pass
self.isweb = True
if not input: logging.warn("input is %s" % input) ; raise NoInput(input)
self.txt = fromenc(input[0].strip(), self.bot.encoding)
self.nick = self.userhost.split("@")[0]
self.auth = fromenc(self.userhost)
self.stripped = stripped(self.auth)
self.channel = stripped(self.userhost)
logging.debug(u'tornado - parsed - %s - %s' % (self.txt, self.userhost))
self.prepare()
return self
def parsesocket(self, handler, message):
""" parse request/response into a WebEvent. """
self.handler = handler
try: data = LazyDict(json.loads(message))
except Exception, ex: logging.error("failed to parse data: %s - %s" % (message, str(ex))) ; return self
logging.info("incoming: %s" % message)
self.div = data.target
self.userhost = tornado.escape.xhtml_escape(handler.current_user)
if not self.userhost: raise Exception("no current user.")
self.isweb = True
input = data.cmnd
self.how = data.how or self.how
logging.info("cmnd is %s - how is %s" % (input, self.how))
self.origtxt = fromenc(input.strip(), self.bot.encoding)
self.txt = self.origtxt
self.usercmnd = self.txt and self.txt.split()[0]
self.groupchat = False
self.nick = self.userhost.split("@")[0]
self.auth = fromenc(self.userhost)
self.stripped = stripped(self.auth)
self.domain = None
self.channel = stripped(self.userhost)
logging.debug(u'tornado - parsed - %s - %s' % (self.txt, self.userhost))
self.makeargs()
return self
def parse(self, handler, request):
""" parse request/response into a WebEvent. """
#logging.warn(dir(handler))
#logging.warn(dir(request))
#logging.warn(request.arguments)
#logging.warn(request.body)
self.handler = handler
self.request = request
self.userhost = tornado.escape.xhtml_escape(handler.current_user)
if not self.userhost: raise Exception("no current user.")
try: how = request.arguments['how'][0]
except KeyError: how = "background"
if not how: how = "background"
self.how = how
if self.how == "undefined": self.how = "overwrite"
logging.warn("web - how is %s" % self.how)
#self.webchan = request.headers.get('webchan')
#input = request.headers.get('content') or request.headers.get('cmnd')
if not input:
try: input = request.arguments['content'] or request.arguments['cmnd']
except KeyError: pass
self.isweb = True
logging.warn("input is %s" % input)
self.origtxt = fromenc(input[0].strip(), self.bot.encoding)
self.txt = self.origtxt
self.usercmnd = self.txt and self.txt.split()[0]
self.groupchat = False
self.nick = self.userhost.split("@")[0]
self.auth = fromenc(self.userhost)
self.stripped = stripped(self.auth)
self.domain = None
self.channel = stripped(self.userhost)
logging.debug(u'tornado - parsed - %s - %s' % (self.txt, self.userhost))
self.makeargs()
return self
def parse(self, handler, request, path=None):
""" parse request/response into a WebEvent. """
self.handler = handler
self.request = request
self.userhost = tornado.escape.xhtml_escape(handler.current_user)
if not self.userhost: raise Exception("no current user.")
try: how = request.arguments['how'][0]
except KeyError: how = "background"
if not how: how = "background"
self.how = how
if self.how == "undefined": self.how = "overwrite"
logging.warn("web - how is %s" % self.how)
input = request.headers.get('content') or request.headers.get('cmnd')
if not input:
try: input = request.arguments['content'] or request.arguments['cmnd']
except KeyError: pass
self.isweb = True
if not input: logging.warn("input is %s" % input) ; raise NoInput(input)
self.txt = fromenc(input[0].strip(), self.bot.encoding)
self.nick = self.userhost.split("@")[0]
self.auth = fromenc(self.userhost)
self.stripped = stripped(self.auth)
self.channel = stripped(self.userhost)
logging.debug(u'tornado - parsed - %s - %s' % (self.txt, self.userhost))
self.prepare()
return self
def parseAPI(self, handler, apitype, path):
""" parse request/response into a WebEvent. """
#logging.warn(dir(handler))
#logging.warn(dir(handler.request))
#logging.warn(request.arguments)
#logging.warn(request.body)
self.handler = handler
self.request = handler.request
self.query = self.request.query
self.upath = path
self.apitype = apitype
self.userhost = tornado.escape.xhtml_escape(handler.current_user)
if not self.userhost: raise Exception("no current user.")
input = path
self.isweb = True
logging.warn("input is %s" % input)
if not input: raise NoInput(input)
self.txt = fromenc(input.strip(), self.bot.encoding)
self.nick = self.userhost.split("@")[0]
self.auth = fromenc(self.userhost)
self.stripped = stripped(self.auth)
self.channel = stripped(self.userhost)
logging.debug(u'tornado - parsed - %s - %s' % (self.txt, self.userhost))
self.prepare()
return self
def doevent(self, event):
""" dispatch an event. """
time.sleep(0.01)
if not self.cfg:
raise Exception(
"eventbase - cfg is not set .. can't handle event.")
return
if not event: raise NoEventProvided()
self.ecounter += 1
if event.userhost in self.state['ignore']:
logging.warn("%s - ignoring %s" % (self.cfg.name, event.userhost))
return
try:
if event.isremote():
self.doremote(event)
return
if event.type == "groupchat" and event.fromm in self.ids:
logging.debug("%s - receiving groupchat from self (%s)" %
(self.cfg.name, event.fromm))
return
event.txt = self.inputmorphs.do(fromenc(event.txt, self.encoding),
event)
except UnicodeDecodeError:
logging.warn("%s - got decode error in input .. ingoring" %
self.cfg.name)
return
event.bind(self, noraise=True)
try:
logging.debug("%s - event dump: %s" %
(self.cfg.name, event.dump()))
except:
pass
self.status = "callback"
starttime = time.time()
if self.closed:
if self.gatekeeper.isblocked(event.origin):
logging.warn("%s is blocked" % event.origin)
return
if event.status == "done":
logging.warn("%s - event is done .. ignoring" % self.cfg.name)
return
if event.msg or event.isdcc: event.speed = 2
if event.channelchanged:
cmnds.dispatch(self, event)
return
e1 = cpy(event)
first_callbacks.check(self, e1)
if not e1.stop:
callbacks.check(self, e1)
if not e1.stop: last_callbacks.check(self, e1)
event.callbackdone = True
waiter.check(self, event)
#mainsink.put(5, self, event)
self.lastiter = time.time()
self.benice()
return event
def _readloop(self):
""" proces all incoming data. """
logging.debug('%s - starting readloop' % self.name)
self.prevbuffer = ""
self.buffer = ""
self.error = ""
data = ""
while not self.stopped:
time.sleep(0.001)
try:
data = jabberstrip(fromenc(self.connection.read()))
logging.debug(u"%s - incoming: %s" % (self.name, data))
if data.endswith("</stream:stream>"):
logging.error("%s - end of stream detected" % self.name)
self.error = "streamend"
self.disconnectHandler(
Exception('remote %s disconnected' % self.host))
break
if data == "":
logging.error('%s - remote disconnected' % self.name)
self.error = 'disconnected'
self.disconnectHandler(
Exception('remote %s disconnected' % self.host))
break
if True:
self.buffer = u"%s%s" % (self.buffer, data)
#splitted = self.buffer.split(">")
#lastitem = splitted[-1]
handlers = self.handlers.keys()
handlers.append("/")
for handler in handlers:
target = "%s>" % handler
index = self.buffer.find(target)
if index != -1:
try:
if self.loop_one(self.buffer[:index +
len(target)]):
self.buffer = self.buffer[index + 1 +
len(target):]
else:
self.buffer = ""
break
except:
handle_exception()
except xml.parsers.expat.ExpatError, ex:
logging.error("%s - %s - %s" % (self.name, str(ex), data))
self.buffer = ""
self.error = str(ex)
self.disconnectHandler(ex)
break
except Exception, ex:
handle_exception()
self.error = str(ex)
self.disconnectHandler(ex)
break
def parsesocket(self, handler, message):
""" parse request/response into a WebEvent. """
self.handler = handler
try: data = LazyDict(json.loads(message))
except Exception, ex: logging.error("failed to parse data: %s - %s" % (message, str(ex))) ; return self
logging.info("incoming: %s" % message)
self.div = data.target
self.userhost = tornado.escape.xhtml_escape(handler.current_user)
if not self.userhost: raise Exception("no current user.")
self.isweb = True
input = data.cmnd
self.how = data.how or self.how
logging.warn("cmnd is %s - how is %s" % (input, self.how))
self.txt = fromenc(input.strip(), self.bot.encoding)
self.nick = self.userhost.split("@")[0]
self.auth = fromenc(self.userhost)
self.stripped = stripped(self.auth)
self.channel = stripped(self.userhost)
logging.debug(u'tornado - parsed - %s - %s' % (self.txt, self.userhost))
self.prepare()
return self
def _readloop(self):
""" proces all incoming data. """
logging.debug('%s - starting readloop' % self.name)
self.prevbuffer = ""
self.buffer = ""
self.error = ""
data = ""
while not self.stopped:
time.sleep(0.001)
try:
data = jabberstrip(fromenc(self.connection.read()))
logging.debug(u"%s - incoming: %s" % (self.name, data))
if data.endswith("</stream:stream>"):
logging.error("%s - end of stream detected" % self.name)
self.error = "streamend"
self.disconnectHandler(Exception('remote %s disconnected' % self.host))
break
if data == "":
logging.error('%s - remote disconnected' % self.name)
self.error = 'disconnected'
self.disconnectHandler(Exception('remote %s disconnected' % self.host))
break
if True:
self.buffer = u"%s%s" % (self.buffer, data)
#splitted = self.buffer.split(">")
#lastitem = splitted[-1]
handlers = self.handlers.keys()
handlers.append("/")
for handler in handlers:
target = "%s>" % handler
index = self.buffer.find(target)
if index != -1:
try:
if self.loop_one(self.buffer[:index+len(target)]):
self.buffer = self.buffer[index+1+len(target):]
else:
self.buffer = ""
break
except: handle_exception()
except xml.parsers.expat.ExpatError, ex:
logging.error("%s - %s - %s" % (self.name, str(ex), data))
self.buffer = ""
self.error = str(ex)
self.disconnectHandler(ex)
break
except Exception, ex:
handle_exception()
self.error = str(ex)
self.disconnectHandler(ex)
break
def _readloop(self):
""" proces all incoming data. """
logging.debug('%s - starting readloop' % self.cfg.name)
self.prevbuffer = u""
self.buffer = u""
self.error = u""
data = u""
while not self.stopped and not self.stopreadloop:
try:
data = jabberstrip(fromenc(self.connection.read()), allowed=["\n", ])
if self.stopped or self.stopreadloop: break
logging.info(u"< %s (%s)" % (data, len(data)))
if data.endswith("</stream:stream>"):
logging.error("%s - end of stream detected" % self.cfg.name)
self.error = "streamend"
self.disconnectHandler(Exception('remote %s disconnected' % self.cfg.host))
break
if data == "":
logging.error('%s - remote disconnected' % self.cfg.name)
self.error = 'disconnected'
self.disconnectHandler(Exception('remote %s disconnected' % self.cfg.host))
break
if True:
self.buffer = u"%s%s" % (self.buffer, data)
handlers = self.handlers.keys()
handlers.append("/")
for handler in handlers:
target = u"%s>" % handler
index = self.buffer.find(target)
if index != -1:
try:
if self.loop_one(self.buffer[:index+len(target)]):
self.buffer = self.buffer[index+1+len(target):]
else:
self.buffer = u""
break
except: handle_exception()
except AttributeError, ex:
logging.error(u"%s - connection disappeared: %s" % (self.cfg.name, str(ex)))
self.buffer = u""
self.error = str(ex)
self.disconnectHandler(ex)
break
except xml.parsers.expat.ExpatError, ex:
logging.error(u"%s - %s - %s" % (self.cfg.name, str(ex), data))
self.buffer = u""
self.error = str(ex)
self.disconnectHandler(ex)
break
def doevent(self, event):
""" dispatch an event. """
if not event: raise NoEventProvided()
if event.isremote():
self.doremote(event)
return
event.txt = self.inputmorphs.do(fromenc(event.txt, self.encoding))
msg = "%s - %s - %s - %s" % (self.name, event.auth, event.how,
event.cbtype)
if event.cbtype in ['NOTICE']:
logging.warn("%s - %s - %s" % (self.name, event.nick, event.txt))
else:
try:
int(event.cbtype)
logging.debug("======== start handling local event ========")
logging.debug(msg)
except (ValueError, TypeError):
if event.cbtype in ['PING', 'PRESENCE'
] or event.how == "background":
logging.debug(
"======== start handling local event ========")
logging.debug(msg)
else:
logging.info(
"======== start handling local event ========")
logging.info(msg)
logging.debug(event.dump())
event.prepare(self)
self.status = "callback"
starttime = time.time()
if self.closed:
if self.gatekeeper.isblocked(event.origin): return
if event.status == "done":
logging.debug("%s - event is done .. ignoring" % self.name)
return
self.reloadcheck(event)
if event.msg or event.isdcc: event.speed = 2
e1 = cpy(event)
first_callbacks.check(self, e1)
if not e1.stop:
callbacks.check(self, e1)
if not e1.stop: last_callbacks.check(self, e1)
event.callbackdone = True
if not self.isgae:
import asyncore
asyncore.loop()
return event
def doevent(self, event):
""" dispatch an event. """
time.sleep(0.01)
if not self.cfg: raise Exception("eventbase - cfg is not set .. can't handle event.") ; return
if not event: raise NoEventProvided()
try:
if event.isremote(): self.doremote(event) ; return
if event.type == "groupchat" and event.fromm in self.ids:
logging.warn("%s - receiving groupchat from self (%s)" % (self.cfg.name, event.fromm))
return
event.txt = self.inputmorphs.do(fromenc(event.txt, self.encoding), event)
except UnicodeDecodeError: logging.warn("%s - got decode error in input .. ingoring" % self.cfg.name) ; return
logtxt = "%s - %s ======== start handling local event ======== %s" % (self.cfg.name, event.cbtype, event.userhost)
if event.cbtype in ['NOTICE']: logging.warn("%s - %s - %s" % (self.cfg.name, event.nick, event.txt))
else:
try:
int(event.cbtype)
logging.debug(logtxt)
except (ValueError, TypeError):
if event.cbtype in ['PING', 'PRESENCE'] or event.how == "background":
logging.debug(logtxt)
else: logging.info(logtxt)
event.bind(self)
try: logging.debug("%s - event dump: %s" % (self.cfg.name, event.dump()))
except: pass
self.status = "callback"
starttime = time.time()
if self.closed:
if self.gatekeeper.isblocked(event.origin): return
if event.status == "done":
logging.debug("%s - event is done .. ignoring" % self.cfg.name)
return
self.reloadcheck(event)
if event.msg or event.isdcc: event.speed = 2
e1 = event
first_callbacks.check(self, e1)
if not e1.stop:
callbacks.check(self, e1)
if not e1.stop: last_callbacks.check(self, e1)
event.callbackdone = True
waiter.check(self, event)
#self.benice(event)
return event
def doevent(self, event):
""" dispatch an event. """
time.sleep(0.01)
if not self.cfg: raise Exception("eventbase - cfg is not set .. can't handle event.") ; return
if not event: raise NoEventProvided()
self.ecounter += 1
if event.userhost in self.state['ignore']: logging.warn("%s - ignoring %s" % (self.cfg.name, event.userhost)) ; return
try:
if event.isremote(): self.doremote(event) ; return
if event.type == "groupchat" and event.fromm in self.ids:
logging.debug("%s - receiving groupchat from self (%s)" % (self.cfg.name, event.fromm))
return
event.txt = self.inputmorphs.do(fromenc(event.txt, self.encoding), event)
except UnicodeDecodeError: logging.warn("%s - got decode error in input .. ingoring" % self.cfg.name) ; return
event.bind(self, noraise=True)
try: logging.debug("%s - event dump: %s" % (self.cfg.name, event.dump()))
except: pass
self.status = "callback"
starttime = time.time()
if self.closed:
if self.gatekeeper.isblocked(event.origin):
logging.warn("%s is blocked" % event.origin) ; return
if event.status == "done":
logging.warn("%s - event is done .. ignoring" % self.cfg.name)
return
if event.msg or event.isdcc: event.speed = 2
if event.channelchanged: cmnds.dispatch(self, event) ; return
e1 = cpy(event)
first_callbacks.check(self, e1)
if not e1.stop:
callbacks.check(self, e1)
if not e1.stop: last_callbacks.check(self, e1)
event.callbackdone = True
waiter.check(self, event)
#mainsink.put(5, self, event)
self.lastiter = time.time()
self.benice()
return event
def doevent(self, event):
""" dispatch an event. """
if not event: raise NoEventProvided()
if event.isremote(): self.doremote(event) ; return
event.txt = self.inputmorphs.do(fromenc(event.txt, self.encoding))
msg = "%s - %s - %s - %s" % (self.name, event.auth, event.how, event.cbtype)
if event.cbtype in ['NOTICE']: logging.warn("%s - %s - %s" % (self.name, event.nick, event.txt))
else:
try:
int(event.cbtype)
logging.debug("======== start handling local event ========")
logging.debug(msg)
except (ValueError, TypeError):
if event.cbtype in ['PING', 'PRESENCE'] or event.how == "background":
logging.debug("======== start handling local event ========")
logging.debug(msg)
else: logging.info("======== start handling local event ========") ; logging.info(msg)
logging.debug(event.dump())
event.prepare(self)
self.status = "callback"
starttime = time.time()
if self.closed:
if self.gatekeeper.isblocked(event.origin): return
if event.status == "done":
logging.debug("%s - event is done .. ignoring" % self.name)
return
self.reloadcheck(event)
if event.msg or event.isdcc: event.speed = 2
e1 = cpy(event)
first_callbacks.check(self, e1)
if not e1.stop:
callbacks.check(self, e1)
if not e1.stop: last_callbacks.check(self, e1)
event.callbackdone = True
if not self.isgae: import asyncore ; asyncore.loop()
return event
if not input:
try:
input = request.params.getone(
'content') or request.params.getone('cmnd')
except KeyError:
input = ""
except Exception, ex:
input = ""
handle_exception()
if not input:
try:
input = request.GET['content'] or request.GET['cmnd']
except KeyError:
pass
self.isweb = True
self.origtxt = fromenc(input.strip(), self.bot.encoding)
self.txt = self.origtxt
self.usercmnd = self.txt and self.txt.split()[0]
self.groupchat = False
self.response = response
self.request = request
(userhost, user, u, nick) = checkuser(response, request, self)
self.userhost = fromenc(userhost)
self.nick = fromenc(nick)
self.auth = fromenc(userhost)
self.stripped = stripped(self.auth)
self.domain = None
self.channel = stripped(userhost)
logging.debug(u'web - parsed - %s - %s' % (self.txt, self.userhost))
self.makeargs()
return self
self.how = how
if self.how == "undefined": self.how = "normal"
logging.warn("web - how is %s" % self.how)
self.webchan = request.get('webchan')
input = request.get('content') or request.get('cmnd')
if not input:
try: input = request.params.getone('content') or request.params.getone('cmnd')
except KeyError: input = ""
except Exception, ex:
input = ""
handle_exception()
if not input:
try: input = request.GET['content'] or request.GET['cmnd']
except KeyError: pass
self.isweb = True
self.origtxt = fromenc(input.strip(), self.bot.encoding)
self.txt = self.origtxt
self.usercmnd = self.txt and self.txt.split()[0]
self.groupchat = False
self.response = response
self.request = request
(userhost, user, u, nick) = checkuser(response, request, self)
self.userhost = fromenc(userhost)
self.nick = fromenc(nick)
self.auth = fromenc(userhost)
self.stripped = stripped(self.auth)
self.domain = None
self.channel = stripped(userhost)
logging.debug(u'web - parsed - %s - %s' % (self.txt, self.userhost))
self.makeargs()
return self
def _readloop(self):
""" loop on the socketfile. """
self.stopreadloop = False
self.stopped = False
doreconnect = True
timeout = 1
logging.info('%s - starting readloop' % self.name)
prevtxt = ""
while not self.stopped and not self.stopreadloop and self.sock and self.fsock:
try:
time.sleep(0.01)
if self.cfg.has_key('ssl') and self.cfg['ssl']:
intxt = inputmorphs.do(self.sock.read()).split('\n')
else:
intxt = inputmorphs.do(self.fsock.readline()).split('\n')
if self.stopreadloop or self.stopped:
doreconnect = 0
break
if not intxt or not intxt[0]:
doreconnect = 1
break
if prevtxt:
intxt[0] = prevtxt + intxt[0]
prevtxt = ""
if intxt[-1] != '':
prevtxt = intxt[-1]
intxt = intxt[:-1]
for r in intxt:
try:
r = strippedtxt(r.rstrip(), ["\001", "\002", "\003"])
rr = unicode(fromenc(r.rstrip(), self.encoding))
except UnicodeDecodeError:
logging.warn("%s - decode error - ignoring" %
self.name)
continue
if not rr: continue
res = rr
logging.debug(u"%s - %s" % (self.name, res))
try:
ievent = IrcEvent().parse(self, res)
except Exception, ex:
handle_exception()
continue
if ievent:
self.handle_ievent(ievent)
timeout = 1
except UnicodeError:
handle_exception()
continue
except socket.timeout:
if self.stopped or self.stopreadloop: break
timeout += 1
if timeout > 2:
doreconnect = 1
logging.warn('%s - no pong received' % self.name)
break
logging.debug("%s - socket timeout" % self.name)
pingsend = self.ping()
if not pingsend:
doreconnect = 1
break
continue
except socket.sslerror, ex:
if self.stopped or self.stopreadloop: break
if not 'timed out' in str(ex):
handle_exception()
doreconnect = 1
break
timeout += 1
if timeout > 2:
doreconnect = 1
logging.warn('%s - no pong received' % self.name)
break
logging.error("%s - socket timeout" % self.name)
pingsend = self.ping()
if not pingsend:
doreconnect = 1
break
continue
except IOError, ex:
if self.blocking and 'temporarily' in str(ex):
time.sleep(0.5)
continue
if not self.stopped:
logging.error('%s - connecting error: %s' %
(self.name, str(ex)))
handle_exception()
doreconnect = 1
break
def _readloop(self):
""" loop on the socketfile. """
self.stopreadloop = False
self.stopped = False
doreconnect = True
timeout = 1
logging.debug('%s - starting readloop' % self.cfg.name)
prevtxt = ""
while not self.stopped and not self.stopreadloop and self.sock and self.fsock:
try:
time.sleep(0.01)
if self.cfg.has_key('ssl') and self.cfg['ssl']: intxt = inputmorphs.do(self.sock.read()).split('\n')
else: intxt = inputmorphs.do(self.fsock.readline()).split('\n')
if self.stopreadloop or self.stopped:
doreconnect = 0
break
if intxt == ["",]:
logging.error("remote disconnected")
doreconnect = 1
break
if prevtxt:
intxt[0] = prevtxt + intxt[0]
prevtxt = ""
if intxt[-1] != '':
prevtxt = intxt[-1]
intxt = intxt[:-1]
for r in intxt:
if not r: continue
try:
r = strippedtxt(r.rstrip(), ["\001", "\002", "\003"])
rr = unicode(fromenc(r.rstrip(), self.encoding))
except UnicodeDecodeError:
if not r: logging.warn("decode error - ignoring (%s)" % self.cfg.name) ; continue
rr = r
if not rr: continue
res = rr
try:
ievent = IrcEvent().parse(self, res)
except Exception, ex:
handle_exception()
continue
try:
if int(ievent.cmnd) > 400: logging.error(u"< %s (%s)" % (res, self.cfg.name))
elif int(ievent.cmnd) >= 300: logging.info(u"< %s (%s)" % (res, self.cfg.name))
except ValueError:
if not res.startswith("PING") and not res.startswith("NOTICE"): logging.warn(u"< %s (%s)" % (res, self.cfg.name))
else: logging.info(u"< %s (%s)" % (res, self.cfg.name))
if ievent: self.handle_ievent(ievent)
timeout = 1
except UnicodeError:
handle_exception()
continue
except socket.timeout, ex:
logging.warn("socket timeout (%s)" % self.cfg.name)
self.error = str(ex)
if self.stopped or self.stopreadloop: break
timeout += 1
if timeout > 2:
doreconnect = 1
logging.warn('no pong received (%s)' % self.cfg.name)
break
pingsend = self.ping()
if not pingsend:
doreconnect = 1
break
continue
except socket.sslerror, ex:
self.error = str(ex)
if self.stopped or self.stopreadloop: break
if not 'timed out' in str(ex):
handle_exception()
doreconnect = 1
break
timeout += 1
if timeout > 2:
doreconnect = 1
logging.warn('no pong received (%s)' % self.cfg.name)
break
logging.warn("socket timeout (%s)" % self.cfg.name)
pingsend = self.ping()
if not pingsend:
doreconnect = 1
break
continue
def _readloop(self):
""" loop on the socketfile. """
self.stopreadloop = False
self.stopped = False
doreconnect = True
timeout = 1
logging.debug('%s - starting readloop' % self.cfg.name)
prevtxt = ""
while not self.stopped and not self.stopreadloop and self.sock and self.fsock:
try:
time.sleep(0.01)
if self.cfg.has_key('ssl') and self.cfg['ssl']:
intxt = inputmorphs.do(self.sock.read()).split('\n')
else:
intxt = inputmorphs.do(self.fsock.readline()).split('\n')
if self.stopreadloop or self.stopped:
doreconnect = 0
break
if intxt == [
"",
]:
logging.error("remote disconnected")
doreconnect = 1
break
if prevtxt:
intxt[0] = prevtxt + intxt[0]
prevtxt = ""
if intxt[-1] != '':
prevtxt = intxt[-1]
intxt = intxt[:-1]
for r in intxt:
if not r: continue
try:
r = strippedtxt(r.rstrip(), ["\001", "\002", "\003"])
rr = unicode(fromenc(r.rstrip(), self.encoding))
except UnicodeDecodeError:
if not r:
logging.warn("decode error - ignoring (%s)" %
self.cfg.name)
continue
rr = r
if not rr: continue
res = rr
try:
ievent = IrcEvent().parse(self, res)
except Exception, ex:
handle_exception()
continue
try:
if int(ievent.cmnd) > 400:
logging.error(u"< %s (%s)" % (res, self.cfg.name))
elif int(ievent.cmnd) >= 300:
logging.info(u"< %s (%s)" % (res, self.cfg.name))
except ValueError:
if not res.startswith("PING") and not res.startswith(
"NOTICE"):
logging.warn(u"< %s (%s)" % (res, self.cfg.name))
else:
logging.info(u"< %s (%s)" % (res, self.cfg.name))
if ievent: self.handle_ievent(ievent)
timeout = 1
except UnicodeError:
handle_exception()
continue
except socket.timeout, ex:
logging.warn("socket timeout (%s)" % self.cfg.name)
self.error = str(ex)
if self.stopped or self.stopreadloop: break
timeout += 1
if timeout > 2:
doreconnect = 1
logging.warn('no pong received (%s)' % self.cfg.name)
break
pingsend = self.ping()
if not pingsend:
doreconnect = 1
break
continue
except socket.sslerror, ex:
self.error = str(ex)
if self.stopped or self.stopreadloop: break
if not 'timed out' in str(ex):
handle_exception()
doreconnect = 1
break
timeout += 1
if timeout > 2:
doreconnect = 1
logging.warn('no pong received (%s)' % self.cfg.name)
break
logging.warn("socket timeout (%s)" % self.cfg.name)
pingsend = self.ping()
if not pingsend:
doreconnect = 1
break
continue
def _readloop(self):
""" loop on the socketfile. """
self.stopreadloop = False
self.stopped = False
doreconnect = True
timeout = 1
logging.warn('%s - starting readloop' % self.cfg.name)
prevtxt = ""
while not self.stopped and not self.stopreadloop and self.sock and self.fsock:
try:
time.sleep(0.01)
if self.cfg.has_key('ssl') and self.cfg['ssl']: intxt = inputmorphs.do(self.sock.read()).split('\n')
#else: intxt = inputmorphs.do(self.fsock.readline()).split('\n')
else:
try: [i, o, e] = select.select([self.sock], [], [])
except socket.error: doreconnect = False ; break
if i: intxt = inputmorphs.do(self.sock.recv(600)).split('\n')
if self.stopreadloop or self.stopped:
doreconnect = 0
break
if not i: time.sleep(0.1) ; continue
if not intxt:
doreconnect = 1
break
if prevtxt:
intxt[0] = prevtxt + intxt[0]
prevtxt = ""
if intxt[-1] != '':
prevtxt = intxt[-1]
intxt = intxt[:-1]
for r in intxt:
if not r: continue
try:
r = strippedtxt(r.rstrip(), ["\001", "\002", "\003"])
rr = unicode(fromenc(r.rstrip(), self.encoding))
except UnicodeDecodeError:
logging.warn("%s - decode error - ignoring" % self.cfg.name)
continue
if not rr: continue
res = rr
logging.info(u"%s - %s" % (self.cfg.name, res))
try:
ievent = IrcEvent().parse(self, res)
except Exception, ex:
handle_exception()
continue
if ievent:
self.handle_ievent(ievent)
timeout = 1
except UnicodeError:
handle_exception()
continue
#except socket.SSLError, ex: logging.error("%s - ssl error: %s" % (self.cfg.name, str(ex))) ; break
except socket.timeout, ex:
logging.debug("%s - socket timeout" % self.cfg.name)
self.error = str(ex)
if self.stopped or self.stopreadloop: break
timeout += 1
if timeout > 2:
doreconnect = 1
logging.warn('%s - no pong received' % self.cfg.name)
break
pingsend = self.ping()
if not pingsend:
doreconnect = 1
break
continue
except socket.sslerror, ex:
self.error = str(ex)
if self.stopped or self.stopreadloop: break
if not 'timed out' in str(ex):
handle_exception()
doreconnect = 1
break
timeout += 1
if timeout > 2:
doreconnect = 1
logging.warn('%s - no pong received' % self.cfg.name)
break
logging.error("%s - socket timeout" % self.cfg.name)
pingsend = self.ping()
if not pingsend:
doreconnect = 1
break
continue
