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)
self.createdfrom = str(handler)
logging.debug('tornado - parsed - %s - %s' % (self.txt, self.userhost))
self.prepare()
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)
self.createdfrom = str(handler)
logging.debug('tornado - parsed - %s - %s' % (self.txt, self.userhost))
self.prepare()
return self
def doevent(self, event=None):
""" dispatch an event. """
time.sleep(0.01)
if not event: event = self.make_event()
if not self.cfg: raise Exception("eventbase - cfg is not set .. can't handle event.") ; return
if not event: raise NoEventProvided()
self.ecounter += 1
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)
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
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
waiter.check(self, event)
return event
def parsesocket(self, handler, message):
""" parse request/response into a WebEvent. """
self.handler = handler
try: data = LazyDict(json.loads(message))
except Exception as 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)
self.createdfrom = str(handler)
logging.debug('tornado - parsed - %s - %s' % (self.txt, self.userhost))
self.prepare()
return self
def _readloop(self):
""" loop on the socketfile. """
self.stopreadloop = False
self.stopped = False
self.goreconnect = 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 'ssl' in self.cfg and self.cfg['ssl']: intxt = self.sock.read().split('\n')
else: intxt = self.fsock.readline().split('\n')
if self.stopreadloop or self.stopped:
self.goreconnect = 0
break
if intxt == ["",]:
logging.error("remote disconnected")
self.goreconnect = 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 = str(fromenc(r.rstrip(), self.encoding))
except UnicodeDecodeError:
logging.warn("decode error - ignoring (%s)" % self.cfg.name)
continue
if not rr: continue
res = rr
try:
ievent = IrcEvent().parse(self, res)
except Exception as ex:
handle_exception()
continue
try:
if int(ievent.cmnd) > 400: logging.error("< %s - %s" % (res, self.cfg.name))
elif int(ievent.cmnd) >= 300: logging.info("< %s - %s" % (res, self.cfg.name))
except ValueError:
if not res.startswith("PING") and not res.startswith("NOTICE"): logging.warn("< %s - %s" % (res, self.cfg.name))
else: logging.info("< %s - %s" % (res, self.cfg.name))
if ievent: self.handle_ievent(ievent)
timeout = 1
except UnicodeError as ex:
self.error = str(ex)
logging.warn(self.error)
handle_exception()
continue
except socket.timeout as ex:
self.error = str(ex)
logging.warn(self.error)
if self.stopped or self.stopreadloop: break
timeout += 1
if timeout > 2:
self.goreconnect = True
logging.warn('no pong received (%s)' % self.cfg.name)
break
pingsend = self.ping()
if not pingsend: self.goreconnect = True ; break
continue
except ssl.SSLError as ex:
self.error = str(ex)
logging.warn(self.error)
if self.stopped or self.stopreadloop: break
if not ex.errno == ETIMEOUT:
handle_exception()
self.goreconnect = True
break
timeout += 1
if timeout > 2:
self.goreconnect = True
logging.warn('no pong received (%s)' % self.cfg.name)
break
logging.warn("socket timeout (%s)" % self.cfg.name)
pingsend = self.ping()
if not pingsend: self.goreconnect = True ; break
handle_exception()
except IOError as ex:
self.error = str(ex)
logging.warn(self.error)
if ex.errno in [EAGAIN, EPIPE, EBADF]: time.sleep(1) ; continue
if not self.stopped:
logging.error('connecting error: %s (%s)' % (str(ex), self.cfg.name))
handle_exception()
self.goreconnect = True
break
except socket.error as ex:
self.error = str(ex)
logging.warn(self.error)
if ex.errno in [EAGAIN, EPIPE, EBADF]: time.sleep(0.5) ; continue
if not self.stopped:
logging.error('connecting error: %s (%s)' % (str(ex), self.cfg.name))
self.goreconnect = True
break
except Exception as ex:
self.error = str(ex)
if self.stopped or self.stopreadloop: break
self.goreconnect = True
break
logging.warn('readloop stopped - %s (%s)' % (self.error, self.cfg.name))
self.connectok.clear()
self.connected = False
if self.goreconnect and not self.stopped:
self.goreconnect = False
time.sleep(2)
self.reconnect()
