X-Git-Url: https://jfr.im/git/erebus.git/blobdiff_plain/f4f6442ed217737a1b3783dfd8434e2f7f26f330..HEAD:/erebus.py?ds=sidebyside

diff --git a/erebus.py b/erebus.py
index 01f9a57..fb6fcc8 100644
--- a/erebus.py
+++ b/erebus.py
@@ -1,33 +1,455 @@
 #!/usr/bin/python
+# vim: fileencoding=utf-8
 
-#TODO: tons
+# Erebus IRC bot - Author: John Runyon
+# main startup code
 
-import sys, select
-import bot
+from __future__ import print_function
 
-class Erebus(object):
-	pass
+import os, sys, select, time, traceback, random, gc
+import bot, config, ctlmod, modlib
 
-main = Erebus()
-bots = {}
-fds = {}
-po = select.poll()
+class Erebus(object): #singleton to pass around
+	APIVERSION = 0
+	RELEASE = 0
 
-def setup():
-	global bots, fds
-	bots = {'erebus': bot.Bot(main, 'Erebus', 'erebus', '', 'irc.quakenet.org', 6667, 'Erebus', [])}
+	bots = {}
 	fds = {}
+	numhandlers = {}
+	msghandlers = {}
+	chanhandlers = {}
+	exceptionhandlers = [] # list of (Exception_class, handler_function) tuples
+	users = {}
+	chans = {}
+
+	class User(object):
+		def __init__(self, nick, auth=None):
+			self.nick = nick
+			if auth is None:
+				self.auth = None
+			else:
+				self.auth = auth.lower()
+			self.checklevel()
+
+			self.chans = []
+
+		def bind_bot(self, bot):
+			return main._BoundUser(self, bot)
+
+		def msg(self, *args, **kwargs):
+			main.randbot().msg(self, *args, **kwargs)
+		def slowmsg(self, *args, **kwargs):
+			main.randbot().slowmsg(self, *args, **kwargs)
+		def fastmsg(self, *args, **kwargs):
+			main.randbot().fastmsg(self, *args, **kwargs)
+
+		def isauthed(self):
+			return self.auth is not None
+
+		def authed(self, auth):
+			if auth == '0': self.auth = None
+			else: self.auth = auth.lower()
+			self.checklevel()
+
+		def checklevel(self):
+			if self.auth is None:
+				self.glevel = -1
+			else:
+				c = main.query("SELECT level FROM users WHERE auth = %s", (self.auth,))
+				if c:
+					row = c.fetchone()
+					if row is not None:
+						self.glevel = row['level']
+					else:
+						self.glevel = 0
+				else:
+					self.glevel = 0
+			return self.glevel
+
+		def setlevel(self, level, savetodb=True):
+			if savetodb:
+				if level != 0:
+					c = main.query("REPLACE INTO users (auth, level) VALUES (%s, %s)", (self.auth, level))
+				else:
+					c = main.query("DELETE FROM users WHERE auth = %s", (self.auth,))
+					if c == 0: # no rows affected
+						c = True # is fine
+				if c:
+					self.glevel = level
+					return True
+				else:
+					return False
+			else:
+				self.glevel = level
+				return True
+
+		def join(self, chan):
+			if chan not in self.chans: self.chans.append(chan)
+		def part(self, chan):
+			try:
+				self.chans.remove(chan)
+			except: pass
+			return len(self.chans) == 0
+		def quit(self):
+			pass
+		def nickchange(self, newnick):
+			self.nick = newnick
+
+		def __str__(self): return self.nick
+		def __repr__(self): return "<User %r (%d)>" % (self.nick, self.glevel)
+
+	class _BoundUser(object):
+		def __init__(self, user, bot):
+			self.__dict__['_bound_user'] = user
+			self.__dict__['_bound_bot'] = bot
+		def __getattr__(self, name):
+			return getattr(self._bound_user, name)
+		def __setattr__(self, name, value):
+			setattr(self._bound_user, name, value)
+		def msg(self, *args, **kwargs):
+			self._bound_bot.msg(self._bound_user, *args, **kwargs)
+		def slowmsg(self, *args, **kwargs):
+			self._bound_bot.slowmsg(self._bound_user, *args, **kwargs)
+		def fastmsg(self, *args, **kwargs):
+			self._bound_bot.fastmsg(self._bound_user, *args, **kwargs)
+		def __repr__(self): return "<_BoundUser %r %r>" % (self._bound_user, self._bound_bot)
+
+	class Channel(object):
+		def __init__(self, name, bot):
+			self.name = name
+			self.bot = bot
+			self.levels = {}
+
+			self.users = []
+			self.voices = []
+			self.ops = []
+
+			self.deleting = False # if true, the bot will remove cached records of this channel when the bot sees that it has left the channel
+
+			c = main.query("SELECT user, level FROM chusers WHERE chan = %s", (self.name,))
+			if c:
+				row = c.fetchone()
+				while row is not None:
+					self.levels[row['user']] = row['level']
+					row = c.fetchone()
+
+
+		def msg(self, *args, **kwargs):
+			self.bot.msg(self, *args, **kwargs)
+		def slowmsg(self, *args, **kwargs):
+			self.bot.slowmsg(self, *args, **kwargs)
+		def fastmsg(self, *args, **kwargs):
+			self.bot.fastmsg(self, *args, **kwargs)
+
+		def levelof(self, auth):
+			if auth is None:
+				return 0
+			auth = auth.lower()
+			if auth in self.levels:
+				return self.levels[auth]
+			else:
+				return 0
+
+		def setlevel(self, auth, level, savetodb=True):
+			auth = auth.lower()
+			if savetodb:
+				c = main.query("REPLACE INTO chusers (chan, user, level) VALUES (%s, %s, %s)", (self.name, auth, level))
+				if c:
+					self.levels[auth] = level
+					return True
+				else:
+					return False
+			else:
+				self.levels[auth] = level
+				return True
+
+		def userjoin(self, user, level=None):
+			if user not in self.users: self.users.append(user)
+			if level == 'op' and user not in self.ops: self.ops.append(user)
+			if level == 'voice' and user not in self.voices: self.voices.append(user)
+		def userpart(self, user):
+			if user in self.ops: self.ops.remove(user)
+			if user in self.voices: self.voices.remove(user)
+			if user in self.users: self.users.remove(user)
+
+		def userop(self, user):
+			if user in self.users and user not in self.ops: self.ops.append(user)
+		def uservoice(self, user):
+			if user in self.users and user not in self.voices: self.voices.append(user)
+		def userdeop(self, user):
+			if user in self.ops: self.ops.remove(user)
+		def userdevoice(self, user):
+			if user in self.voices: self.voices.remove(user)
+
+		def __str__(self): return self.name
+		def __repr__(self): return "<Channel %r>" % (self.name)
+
+	def __init__(self, cfg):
+		self.mustquit = None
+		self.starttime = time.time()
+		self.cfg = cfg
+		self.trigger = cfg.trigger
+		if os.name == "posix":
+			self.potype = "poll"
+			self.po = select.poll()
+		else: # f.e. os.name == "nt" (Windows)
+			self.potype = "select"
+			self.fdlist = []
+
+	def query(self, sql, parameters=[], noretry=False):
+		# Callers use %s-style (paramstyle='format') placeholders in queries.
+		# There's no provision for a literal '%s' present inside the query; stuff it in a parameter instead.
+		if db_api.paramstyle == 'format' or db_api.paramstyle == 'pyformat': # mysql, postgresql
+			# psycopg actually asks for a mapping with %(name)s style (pyformat) but it will accept %s style.
+			pass
+		elif db_api.paramstyle == 'qmark': # sqlite doesn't like %s style.
+			parameters = [str(p) for p in parameters]
+			sql = sql.replace('%s', '?') # hope that wasn't literal, oopsie
+
+		log_noretry = ''
+		if noretry:
+			log_noretry = ', noretry=True'
+		self.log("[SQL]", "?", "query(%r, %r%s)" % (sql, parameters, log_noretry))
+
+		try:
+			curs = self.db.cursor()
+			res = curs.execute(sql, parameters)
+			if res:
+				return curs
+			else:
+				return res
+		except db_api.DataError as e:
+			self.log("[SQL]", ".", "DB DataError: %r" % (e))
+			return False
+		except db_api.Error as e:
+			self.log("[SQL]", "!", "DB error! %r" % (e))
+			if not noretry:
+				dbsetup()
+				return self.query(sql, parameters, noretry=True)
+			else:
+				raise e
+
+	def querycb(self, cb, *args, **kwargs):
+		# TODO this should either get thrown out with getdb()/returndb(), or else be adjusted to make use of it.
+		def run_query():
+			cb(self.query(*args, **kwargs))
+		threading.Thread(target=run_query).start()
+
+	def newbot(self, nick, user, bind, authname, authpass, server, port, realname):
+		if bind is None: bind = ''
+		obj = bot.Bot(self, nick, user, bind, authname, authpass, server, port, realname)
+		self.bots[nick.lower()] = obj
+
+	def newfd(self, obj, fileno):
+		if not isinstance(obj, modlib.Socketlike):
+			raise Exception('Attempted to hook a socket without a class to process data')
+		self.fds[fileno] = obj
+		if self.potype == "poll":
+			self.po.register(fileno, select.POLLIN)
+		elif self.potype == "select":
+			self.fdlist.append(fileno)
+	def delfd(self, fileno):
+		del self.fds[fileno]
+		if self.potype == "poll":
+			self.po.unregister(fileno)
+		elif self.potype == "select":
+			self.fdlist.remove(fileno)
+
+	def bot(self, name): #get Bot() by name (nick)
+		return self.bots[name.lower()]
+	def fd(self, fileno): #get Bot() by fd/fileno
+		return self.fds[fileno]
+	def randbot(self): #get Bot() randomly
+		return self.bots[random.choice(list(self.bots.keys()))]
+
+	def user(self, _nick, send_who=False, create=True):
+		nick = _nick.lower()
+
+		if send_who and (nick not in self.users or not self.users[nick].isauthed()):
+			self.randbot().conn.send("WHO %s n%%ant,1" % (nick))
+
+		if nick in self.users:
+			return self.users[nick]
+		elif create:
+			user = self.User(_nick)
+			self.users[nick] = user
+			return user
+		else:
+			return None
+	def channel(self, name): #get Channel() by name
+		if name.lower() in self.chans:
+			return self.chans[name.lower()]
+		else:
+			return None
+
+	def newchannel(self, bot, name):
+		chan = self.Channel(name.lower(), bot)
+		self.chans[name.lower()] = chan
+		return chan
+
+	def poll(self):
+		timeout_seconds = 30
+		if self.potype == "poll":
+			pollres = self.po.poll(timeout_seconds * 1000)
+			return [fd for (fd, ev) in pollres]
+		elif self.potype == "select":
+			return select.select(self.fdlist, [], [], timeout_seconds)[0]
+
+	def connectall(self):
+		for bot in self.bots.values():
+			if bot.conn.state == 0:
+				bot.connect()
+
+	def module(self, name):
+		return ctlmod.modules[name]
+
+	def log(self, source, level, message):
+		print("%09.3f %s [%s] %s" % (time.time() % 100000, source, level, message))
+
+	def getuserbyauth(self, auth):
+		return [u for u in self.users.values() if u.auth == auth.lower()]
+
+	def getdb(self):
+		"""Get a DB object. The object must be returned to the pool after us, using returndb(). This is intended for use from child threads.
+			It should probably be treated as deprecated though. Where possible new modules should avoid using threads.
+			In the future, timers will be provided (manipulating the timeout_seconds of the poll() method), and that should mostly be used in place of threading."""
+		return self.dbs.pop()
+
+	def returndb(self, db):
+		self.dbs.append(db)
+
+	#bind functions
+	def hook(self, word, handler):
+		try:
+			self.msghandlers[word].append(handler)
+		except:
+			self.msghandlers[word] = [handler]
+	def unhook(self, word, handler):
+		if word in self.msghandlers and handler in self.msghandlers[word]:
+			self.msghandlers[word].remove(handler)
+	def hashook(self, word):
+		return word in self.msghandlers and len(self.msghandlers[word]) != 0
+	def gethook(self, word):
+		return self.msghandlers[word]
+
+	def hooknum(self, word, handler):
+		try:
+			self.numhandlers[word].append(handler)
+		except:
+			self.numhandlers[word] = [handler]
+	def unhooknum(self, word, handler):
+		if word in self.numhandlers and handler in self.numhandlers[word]:
+			self.numhandlers[word].remove(handler)
+	def hasnumhook(self, word):
+		return word in self.numhandlers and len(self.numhandlers[word]) != 0
+	def getnumhook(self, word):
+		return self.numhandlers[word]
+
+	def hookchan(self, chan, handler):
+		try:
+			self.chanhandlers[chan].append(handler)
+		except:
+			self.chanhandlers[chan] = [handler]
+	def unhookchan(self, chan, handler):
+		if chan in self.chanhandlers and handler in self.chanhandlers[chan]:
+			self.chanhandlers[chan].remove(handler)
+	def haschanhook(self, chan):
+		return chan in self.chanhandlers and len(self.chanhandlers[chan]) != 0
+	def getchanhook(self, chan):
+		return self.chanhandlers[chan]
+
+	def hookexception(self, exc, handler):
+		self.exceptionhandlers.append((exc, handler))
+	def unhookexception(self, exc, handler):
+		self.exceptionhandlers.remove((exc, handler))
+	def hasexceptionhook(self, exc):
+		return any((True for x,h in self.exceptionhandlers if isinstance(exc, x)))
+	def getexceptionhook(self, exc):
+		return (h for x,h in self.exceptionhandlers if isinstance(exc, x))
+
+
+def dbsetup():
+	main.db = None
+	main.dbs = []
+	dbtype = cfg.get('erebus', 'dbtype', 'mysql')
+	if dbtype == 'mysql':
+		_dbsetup_mysql()
+	elif dbtype == 'sqlite':
+		_dbsetup_sqlite()
+	else:
+		main.log('*', '!', 'Unknown dbtype in config: %s' % (dbtype))
+
+def _dbsetup_mysql():
+	global db_api
+	import MySQLdb as db_api, MySQLdb.cursors
+	for i in range(cfg.get('erebus', 'num_db_connections', 2)-1):
+		main.dbs.append(db_api.connect(host=cfg.dbhost, user=cfg.dbuser, passwd=cfg.dbpass, db=cfg.dbname, cursorclass=MySQLdb.cursors.DictCursor))
+	main.db = db_api.connect(host=cfg.dbhost, user=cfg.dbuser, passwd=cfg.dbpass, db=cfg.dbname, cursorclass=MySQLdb.cursors.DictCursor)
+
+def _dbsetup_sqlite():
+	global db_api
+	import sqlite3 as db_api
+	for i in range(cfg.get('erebus', 'num_db_connections', 2)):
+		main.db = db_api.connect(cfg.dbhost)
+		main.db.row_factory = db_api.Row
+		main.db.isolation_level = None
+		main.dbs.append(main.db)
+
+def setup():
+	global cfg, main
+
+	cfg = config.Config('bot.config')
+
+	if cfg.getboolean('debug', 'gc'):
+		gc.set_debug(gc.DEBUG_LEAK)
+
+	pidfile = open(cfg.pidfile, 'w')
+	pidfile.write(str(os.getpid()))
+	pidfile.close()
+
+	main = Erebus(cfg)
+	dbsetup()
+
+	autoloads = [mod for mod, yes in cfg.items('autoloads') if int(yes) == 1]
+	for mod in autoloads:
+		ctlmod.load(main, mod)
 
-	bots['erebus'].connect()
-	fds[bots['erebus'].conn.fileno()] = bots['erebus']
-	po.register(bots['erebus'].conn.fileno(), select.POLLIN)
+	c = main.query("SELECT nick, user, bind, authname, authpass FROM bots WHERE active = 1")
+	if c:
+		rows = c.fetchall()
+		c.close()
+		for row in rows:
+			main.newbot(row['nick'], row['user'], row['bind'], row['authname'], row['authpass'], cfg.host, cfg.port, cfg.realname)
+	main.connectall()
 
 def loop():
-	poready = po.poll(60000)
-	for (fd,mask) in poready:
-		fds[fd].getdata()
+	poready = main.poll()
+	for fileno in poready:
+		try:
+			data = main.fd(fileno).getdata()
+		except:
+			main.log('*', '!', 'Error receiving data: getdata raised exception for socket %d, closing' % (fileno))
+			traceback.print_exc()
+			data = None
+		if data is None:
+			main.fd(fileno).close()
+		else:
+			for line in data:
+				if cfg.getboolean('debug', 'io'):
+					main.log(str(main.fd(fileno)), 'I', line)
+				try:
+					main.fd(fileno).parse(line)
+				except:
+					main.log('*', '!', 'Error receiving data: parse raised exception for socket %d data %r, ignoring' % (fileno, line))
+					traceback.print_exc()
+	if main.mustquit is not None:
+		main.log('*', '!', 'Core exiting due to: %s' % (main.mustquit))
+		raise main.mustquit
 
 if __name__ == '__main__':
+	try: os.rename('logfile', 'oldlogs/%s' % (time.time()))
+	except: pass
+	sys.stdout = open('logfile', 'w', 1)
+	sys.stderr = sys.stdout
 	setup()
-	while True:
-		loop()
+	while True: loop()