Esempio n. 1
0
        statdict = Statdict()
        s = create_session()
        whokarma = s.query(WhoKarma).filter(WhoKarma.nick==nick).filter(WhoKarma.updown=='down')
        if not whokarma:
            return []
        for i in whokarma:
            statdict.upitem(i.item)
        return statdict.top()

karma = KarmaDb()
Base.metadata.create_all()
assert(karma)

ratelimited = []
limiterlock = thread.allocate_lock()
limlock = lockdec(limiterlock)
nolimiter = False

def size():
    """ return number of kamra items """
    return karma.size()

def search(what, queue):
    rlog(10, 'karma', 'searched for %s' % what)
    result = karma.search(what)
    for i in result:
        queue.put_nowait("%s has karma %s" % (i[0], i[1]))

@limlock
def ratelimit(bot, ievent):
    """ karma rate limiter """
Esempio n. 2
0
# gozerbot/pdod.py
#
#

""" pickled dicts of dicts """

__copyright__ = 'this file is in the public domain'

from gozerbot.generic import lockdec
from persist import Persist
import thread

pdodlock = thread.allocate_lock()
locked = lockdec(pdodlock)
 
class Pdod(Persist):

    """ pickled dicts of dicts """

    def __init__(self, filename):
        Persist.__init__(self, filename)
        if not self.data:
            self.data = {}

    def __getitem__(self, name):
        """ return item with name """
        if self.data.has_key(name):
            return self.data[name]

    @locked
    def save(self):
Esempio n. 3
0
#
""" database interface """

__copyright__ = 'this file is in the public domain'

# gozerbot imports
from gozerbot.config import config
from gozerbot.generic import rlog, lockdec, tolatin1, handle_exception
from gozerbot.datadir import datadir

# basic imports
import thread, os, time, types

# locks
dblock = thread.allocate_lock()
dblocked = lockdec(dblock)


class Db(object):
    """ this class implements a database connection. it connects to the 
        database on initialisation.
    """
    def __init__(self, doconnect=True, dbtype=None, ddir=None, config=config):
        self.datadir = ddir or datadir
        if not os.path.isdir(self.datadir + os.sep + 'db/'):
            os.mkdir(self.datadir + os.sep + 'db/')
        self.config = config
        self.dbname = self.config['dbname'] or ""
        self.dbhost = self.config['dbhost'] or ""
        self.dbuser = self.config['dbuser'] or ""
        self.dbpasswd = self.config['dbpasswd'] or ""
Esempio n. 4
0
from gozerbot.persist.pdod import Pdod
from gozerbot.datadir import datadir
from gozerbot.fleet import fleet
from gozerbot.botbase import BotBase
from gozerbot.plugins import plugins
from gozerbot.threads.thr import start_new_thread, threaded
from gozerbot.periodical import periodical
from gozerbot.morphs import inputmorphs, outputmorphs
from ircevent import Ircevent

# basic imports
import time, thread, socket, threading, os, Queue, random

# locks
outlock = thread.allocate_lock()
outlocked = lockdec(outlock)

# exceptions


class AlreadyConnected(Exception):
    """ already connected exception """

    pass


class AlreadyConnecting(Exception):
    """ bot is already connecting exception """

    pass
Esempio n. 5
0
from gozerbot.commands import cmnds
from gozerbot.callbacks import callbacks, jcallbacks
from gozerbot.persist.persistconfig import PersistConfig
from gozerbot.generic import hourmin, rlog, lockdec
from gozerbot.monitor import outmonitor, jabbermonitor
from gozerbot.plughelp import plughelp
from gozerbot.examples import examples
from gozerbot.irc.ircevent import Ircevent
from gozerbot.fleet import fleet
import time, os, thread

plughelp.add('supylog', 'log irc channels in supybot channellogger format')

outlock = thread.allocate_lock()
outlocked = lockdec(outlock)

cfg = PersistConfig()
cfg.define('channels', [])
cfg.define('logtimestamp', '%Y-%m-%dT%H:%M:%S')
cfg.define('filenametimestamp', '%d-%a-%Y')
cfg.define('nologprefix', '[nolog]')
cfg.define('nologmsg', '-= THIS MESSAGE NOT LOGGED =-')

logfiles = {}
stopped = False

nonchanevents = ['NICK','NOTICE','QUIT']

if not os.path.isdir('logs'):
    os.mkdir('logs')
Esempio n. 6
0
        whokarma = s.query(WhoKarma).filter(WhoKarma.nick == nick).filter(
            WhoKarma.updown == 'down')
        if not whokarma:
            return []
        for i in whokarma:
            statdict.upitem(i.item)
        return statdict.top()


karma = KarmaDb()
Base.metadata.create_all()
assert (karma)

ratelimited = []
limiterlock = thread.allocate_lock()
limlock = lockdec(limiterlock)
nolimiter = False


def size():
    """ return number of kamra items """
    return karma.size()


def search(what, queue):
    rlog(10, 'karma', 'searched for %s' % what)
    result = karma.search(what)
    for i in result:
        queue.put_nowait("%s has karma %s" % (i[0], i[1]))

Esempio n. 7
0
from gozerbot.examples import examples
from gozerbot.callbacks import callbacks, jcallbacks
from gozerbot.plughelp import plughelp
from gozerbot.monitor import saymonitor, jabbermonitor
from gozerbot.aliases import aliases, aliasdel
from gozerbot.users import users
import glob, re, thread, pickle, os, mmap, time

plughelp.add('log', 'logs related commands')

# check if logs dir exists if not create it
if not os.path.isdir('logs'):
    os.mkdir('logs')

loglock = thread.allocate_lock()
locked = lockdec(loglock)

class Logs(object):

    """ hold handles to log files (per channel) """

    def __init__(self, logdir):
        self.logdir = logdir
        self.maps = {}
        self.files = {}
        self.filenames = {}
        self.lock = thread.allocate_lock()
        self.loglist = []
        try:
            loglistfile = open(self.logdir + os.sep + 'loglist', 'r')
            self.loglist = pickle.load(loglistfile)
Esempio n. 8
0
## UPGRADE PART


def upgrade():
    try:
        convertpickle(datadir + os.sep + 'remind', datadir + os.sep + 'plugs' + \
os.sep + 'remind' + os.sep + 'remind')
    except:
        pass


## END UPGRADE PART

remindlock = thread.allocate_lock()
rlocked = lockdec(remindlock)


class Remind(Pdol):
    """ remind object """
    def __init__(self, name):
        Pdol.__init__(self, name)

    @rlocked
    def add(self, who, data):
        """ add a remind txt """
        self[who] = data
        self.save()

    def wouldremind(self, userhost):
        """ check if there is a remind for userhost """
Esempio n. 9
0
# gozerbot/rest/client.py
#
#

""" Rest Client class """

from gozerbot.generic import geturl3, geturl4, posturl, deleteurl, rlog, \
handle_exception, useragent, lockdec, exceptionmsg
from simplejson import loads
from urllib2 import HTTPError, URLError
from httplib import InvalidURL
from urlparse import urlparse
import socket, asynchat, urllib, sys, thread, re, asyncore

restlock = thread.allocate_lock()
locked = lockdec(restlock)

class RestResult(object):

    def __init__(self, url="", name=""):
        self.url = url
        self.name = name
        self.data = None
        self.error = None
        self.status = None
        self.reason = ""

class RestClient(object):

    def __init__(self, url, keyfile=None, certfile=None, port=None):
        if not url.endswith('/'):
Esempio n. 10
0
""" jabber message definition .. types can be normal, chat, groupchat, 
    headline or  error
"""

__copyright__ = 'this file is in the public domain'

# gozerbot imports
from gozerbot.generic import rlog, toenc, fromenc, jabberstrip, makeargrest, lockdec
from gozerbot.eventbase import EventBase

# basic imports
import xmpp, types, time, thread

# locks
replylock = thread.allocate_lock()
replylocked = lockdec(replylock)

class Jabbermsg(xmpp.Message, EventBase):

    """ jabber message object. """

    def __init__(self, msg=None):

        if msg:
            xmpp.Message.__init__(self, node=str(msg))
        else:
            xmpp.Message.__init__(self)

        EventBase.__init__(self)

        if msg:
Esempio n. 11
0
from jabbermsg import Jabbermsg
from jabberpresence import Jabberpresence
from jabberiq import Jabberiq

# xmpp imports
from xmpp.simplexml import Node
import xmpp

# basic imports
import time, Queue, os, threading, thread, types, xml, re

# locks
jabberoutlock = thread.allocate_lock()
jabberinlock = thread.allocate_lock()
connectlock = thread.allocate_lock()
outlocked = lockdec(jabberoutlock)
inlocked = lockdec(jabberinlock)
connectlocked = lockdec(connectlock)


class Jabberbot(BotBase):
    """ jabber bot class. """
    def __init__(self, cfg):
        BotBase.__init__(self, cfg)
        if not self.port:
            self.port = 5222
        self.type = 'jabber'
        self.outqueue = Queue.Queue()
        self.sock = None
        self.me = None
        self.lastin = None
Esempio n. 12
0
    def __init__(self):
        self.data = {}

    def add(self, plugin, version):
        """ add plugin version """
        self.data[plugin] = version
        #self.save()

    def list(self):
        """ list plugin versions """
        return self.data


cfg = Cfg()
installlock = thread.allocate_lock()
locked = lockdec(installlock)

plughelp.add('install', 'install plugin from remote site')

installsites = ['http://gozerplugs.blinkenlights.nl']


class InstallerException(Exception):
    pass


class Installer(object):
    '''
    We're taking care of installing and verifying plugins.
    '''
Esempio n. 13
0
from sqlalchemy.ext.associationproxy import association_proxy
from sqlalchemy.ext.orderinglist import ordering_list
from sqlalchemy import Text, Integer, Sequence, ForeignKey, DateTime
from sqlalchemy import create_engine, Column, String, Table
from sqlalchemy.orm import scoped_session, sessionmaker, relation, create_session

# basic imports
import sqlalchemy, thread, os, time, logging

# debug settings
if config['debug']:
    logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)

# locks
alchemylock = thread.allocate_lock()
dblocked = lockdec(alchemylock)

# vars
Base = declarative_base()
Session = None
engine = None


def geturi(ddir=None, mainconfig=None):
    """  determine database URI from config file """

    d = ddir or datadir

    # set config file
    if mainconfig:
        config = mainconfig
Esempio n. 14
0
""" jabber message definition .. types can be normal, chat, groupchat, 
    headline or  error
"""

__copyright__ = 'this file is in the public domain'

# gozerbot imports
from gozerbot.generic import rlog, toenc, fromenc, jabberstrip, makeargrest, lockdec
from gozerbot.eventbase import EventBase

# basic imports
import xmpp, types, time, thread

# locks
replylock = thread.allocate_lock()
replylocked = lockdec(replylock)


class Jabbermsg(xmpp.Message, EventBase):
    """ jabber message object. """
    def __init__(self, msg=None):

        if msg:
            xmpp.Message.__init__(self, node=str(msg))
        else:
            xmpp.Message.__init__(self)

        EventBase.__init__(self)

        if msg:
            self.orig = msg
Esempio n. 15
0
plughelp.add('remind', 'check if user says something if so do /msg')

## UPGRADE PART

def upgrade():
    try:
        convertpickle(datadir + os.sep + 'remind', datadir + os.sep + 'plugs' + \
os.sep + 'remind' + os.sep + 'remind')
    except:
        pass

## END UPGRADE PART

remindlock = thread.allocate_lock()
rlocked = lockdec(remindlock)

class Remind(Pdol):

    """ remind object """

    def __init__(self, name):
        Pdol.__init__(self, name)

    @rlocked
    def add(self, who, data):
        """ add a remind txt """
        self[who] = data
        self.save()

    def wouldremind(self, userhost):
Esempio n. 16
0
    except IOError, ex:
        if 'No such file' in str(ex):
            rlog(10, 'todo', 'nothing to upgrade')
    except Exception, ex:
        rlog(10, 'todo', "can't upgrade .. reason: %s" % str(ex))
        handle_exception()
    else:
        rlog(10, 'quote', "upgraded %s items" % teller)


## END UPGRADE PART

plughelp.add('todo', 'todo lists')

todolock = thread.allocate_lock()
locked = lockdec(todolock)


class TodoDb(object):
    """ database todo interface """
    @trans
    def reset(self, session, name):
        item = session.query(Todo).filter(Todo.name == name.lower).first()
        session.delete(item)
        return 1

    def size(self):
        """ return number of todo's """
        s = create_session()
        count = s.query(sa.func.count(Todo.indx)).first()[0]
        return count
Esempio n. 17
0
            result.append(j)


def checkfordate(data, date):
    for item in data:
        try:
            d = item["updated"]
        except KeyError:
            continue
        if date == d:
            return True
    return False


rsslock = thread.allocate_lock()
locked = lockdec(rsslock)


class RssException(Exception):
    pass


class Rss301(RssException):
    pass


class RssStatus(RssException):
    pass


class RssBozoException(RssException):
Esempio n. 18
0
                teller += 1  
    except IOError, ex:
        if 'No such file' in str(ex):
            rlog(10, 'todo', 'nothing to upgrade')
    except Exception, ex:
        rlog(10, 'todo', "can't upgrade .. reason: %s" % str(ex))
        handle_exception()
    else:
        rlog(10, 'quote', "upgraded %s items" % teller)

## END UPGRADE PART

plughelp.add('todo', 'todo lists')

todolock = thread.allocate_lock()
locked = lockdec(todolock)

class TodoDb(object):

    """ database todo interface """

    @trans
    def reset(self, session, name): 
        item = session.query(Todo).filter(Todo.name==name.lower).first()
        session.delete(item)
        return 1

    def size(self):
        """ return number of todo's """
        s = create_session()
        count = s.query(sa.func.count(Todo.indx)).first()[0]
Esempio n. 19
0
__copyright__ = 'this file is in the public domain'

from gozerbot.stats import stats
from gozerbot.generic import handle_exception, rlog, lockdec
import threading, re, time, thread

dontshowthreads = [
    'Periodical.runjob',
]

# regular expression to determine thread name
methodre = re.compile('method\s+(\S+)', re.I)
funcre = re.compile('function\s+(\S+)', re.I)

threadlock = thread.allocate_lock()
locked = lockdec(threadlock)


class Botcommand(threading.Thread):
    """ thread for running bot commands .. give feedback of exceptions to
        ircevent argument (second after bot) """
    def __init__(self, group, target, name, args, kwargs):
        threading.Thread.__init__(self, None, target, name, args, kwargs)
        self.name = name
        self.ievent = args[1]
        self.setDaemon(True)

    def run(self):
        """ run the bot command """
        try:
            rlog(10, 'thr', 'running bot command thread %s' % self.name)
Esempio n. 20
0
from gozerbot.examples import examples
from gozerbot.callbacks import callbacks, jcallbacks
from gozerbot.plughelp import plughelp
from gozerbot.monitor import saymonitor, jabbermonitor
from gozerbot.aliases import aliases, aliasdel
from gozerbot.users import users
import glob, re, thread, pickle, os, mmap, time

plughelp.add('log', 'logs related commands')

# check if logs dir exists if not create it
if not os.path.isdir('logs'):
    os.mkdir('logs')

loglock = thread.allocate_lock()
locked = lockdec(loglock)


class Logs(object):
    """ hold handles to log files (per channel) """
    def __init__(self, logdir):
        self.logdir = logdir
        self.maps = {}
        self.files = {}
        self.filenames = {}
        self.lock = thread.allocate_lock()
        self.loglist = []
        try:
            loglistfile = open(self.logdir + os.sep + 'loglist', 'r')
            self.loglist = pickle.load(loglistfile)
        except:
Esempio n. 21
0
from sqlalchemy.ext.associationproxy import association_proxy
from sqlalchemy.ext.orderinglist import ordering_list
from sqlalchemy import Text, Integer, Sequence, ForeignKey, DateTime
from sqlalchemy import create_engine, Column, String, Table
from sqlalchemy.orm import  scoped_session, sessionmaker, relation, create_session

# basic imports
import sqlalchemy, thread, os, time, logging

# debug settings
if config['debug']:
    logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)

# locks
alchemylock = thread.allocate_lock()
dblocked = lockdec(alchemylock)

# vars
Base = declarative_base()
Session = None
engine = None

def geturi(ddir=None, mainconfig=None):

    """  determine database URI from config file """

    d = ddir or datadir

    # set config file
    if mainconfig:
        config = mainconfig 
Esempio n. 22
0
            result.append(j)


def checkfordate(data, date):
    for item in data:
        try:
            d = item['updated']
        except KeyError:
            continue
        if date == d:
            return True
    return False


rsslock = thread.allocate_lock()
locked = lockdec(rsslock)


class RssException(Exception):
    pass


class Rss301(RssException):
    pass


class RssStatus(RssException):
    pass


class RssBozoException(RssException):
Esempio n. 23
0
""" own threading wrapper """

__copyright__ = 'this file is in the public domain'

from gozerbot.stats import stats
from gozerbot.generic import handle_exception, rlog, lockdec
import threading, re, time, thread

dontshowthreads = ['Periodical.runjob', ]

# regular expression to determine thread name
methodre = re.compile('method\s+(\S+)', re.I)
funcre = re.compile('function\s+(\S+)', re.I)

threadlock = thread.allocate_lock()
locked = lockdec(threadlock)

class Botcommand(threading.Thread):

    """ thread for running bot commands .. give feedback of exceptions to
        ircevent argument (second after bot) """

    def __init__(self, group, target, name, args, kwargs):
        threading.Thread.__init__(self, None, target, name, args, kwargs)
        self.name = name
        self.ievent = args[1]
        self.setDaemon(True)

    def run(self):
        """ run the bot command """
        try:
Esempio n. 24
0
                rlog(10, 'infoitem', 'nothing to upgrade')
        except Exception, ex:
            rlog(10, 'infoitem', "can't upgrade: %s" % str(ex))
            return
    rlog(10, 'infoitem', 'upgraded %s infoitems' % str(teller))
    return teller

import thread, os, time

plughelp.add('infoitem', 'also known as factoids .. info can be retrieved \
by keyword or searched')

infolock = thread.allocate_lock()

# create lock descriptor
locked = lockdec(infolock)

class InfoitemsDb(object):

    """ information items """

    @trans 
    def add(self, session, item, description, userhost, ttime):
        """ add an item """
        item = item.lower()
        result = 0
        try:
            newitem = InfoItems(item, description, userhost, datetime.fromtimestamp(ttime))
            session.add(newitem)
            result = 1
        except Exception, ex:
Esempio n. 25
0
from gozerbot.fleet import fleet
from gozerbot.examples import examples
from gozerbot.threads.thr import start_new_thread
from gozerbot.plughelp import plughelp
from gozerbot.persist.persistconfig import PersistConfig
import os, time, thread

plughelp.add('shoutcast', 'query a shoutcast server or periodically watch \
them')

cfg = PersistConfig()
cfg.define('scwatch', 0)
cfg.define('nodes', [])

sclock = thread.allocate_lock()
locked = lockdec(sclock)

class SCwatcher(object):

    def __init__(self):
        self.stop = False
        self.songsplayed = []

    def run(self):
        self.starttime = int(time.time())
        res = ""
        while cfg.get('scwatch') and not self.stop:
            time.sleep(1)
            if self.stop:
                break
            godo = []    
Esempio n. 26
0
""" database interface """

__copyright__ = "this file is in the public domain"

# gozerbot imports
from gozerbot.config import config
from gozerbot.generic import rlog, lockdec, tolatin1, handle_exception
from gozerbot.datadir import datadir

# basic imports
import thread, os, time, types

# locks
dblock = thread.allocate_lock()
dblocked = lockdec(dblock)


class Db(object):

    """ this class implements a database connection. it connects to the 
        database on initialisation.
    """

    def __init__(self, doconnect=True, dbtype=None, ddir=None, config=config):
        self.datadir = ddir or datadir
        if not os.path.isdir(self.datadir + os.sep + "db/"):
            os.mkdir(self.datadir + os.sep + "db/")
        self.config = config
        self.dbname = self.config["dbname"] or ""
        self.dbhost = self.config["dbhost"] or ""
Esempio n. 27
0
from jabbermsg import Jabbermsg
from jabberpresence import Jabberpresence
from jabberiq import Jabberiq

# xmpp imports
from xmpp.simplexml import Node
import xmpp

# basic imports
import time, Queue, os, threading, thread, types, xml, re

# locks
jabberoutlock = thread.allocate_lock()
jabberinlock = thread.allocate_lock()
connectlock = thread.allocate_lock()
outlocked = lockdec(jabberoutlock)
inlocked = lockdec(jabberinlock)
connectlocked = lockdec(connectlock)

class Jabberbot(BotBase):

    """ jabber bot class. """

    def __init__(self, cfg):
        BotBase.__init__(self, cfg)
        if not self.port:
            self.port = 5222
        self.type = 'jabber'
        self.outqueue = Queue.Queue()
        self.sock = None
        self.me = None