Ejemplo n.º 1
0
def main():
    dbpool.runQuery(SQL_CREATE_CAR_TABLE)

    factory = protocol.ServerFactory()
    factory.protocol = CarCenter
    reactor.listenTCP(8000, factory)
    reactor.run()
Ejemplo n.º 2
0
Archivo: web.py Proyecto: chizu/hashi
    def render_GET(self, request, session):
        """Channel history"""
        def render_messages(l):
            request.write(json.dumps(l))
            request.finish()
        msg_sql = """SELECT events.id, source_identities.token, events.args[0:1], events.kind, to_char(events.timestamp, 'IYYY:MM:DD-HH24:MI:SS')
FROM identities
RIGHT OUTER JOIN events on (events.target = identities.id)
JOIN identities as source_identities on (events.source = source_identities.id)
WHERE (identities.token ILIKE %s 
       OR (events.target IS NULL AND %s ILIKE ANY(events.args)))
AND events.observer_email = %s
"""
        query_args = [self.name, self.name, session.email]
        before_sql = "\nAND events.id < %s"
        count_sql = "\nORDER BY events.id DESC LIMIT %s;"
        if "before" in request.args:
            before = int(request.args["before"][0])
            msg_sql += before_sql
            query_args.append(before)
        if "count" in request.args:
            count = max(0, min(int(request.args["count"][0]), 1000))
        else:
            count = 100
        msg_sql += count_sql
        query_args.append(count)
        d = dbpool.runQuery(msg_sql, query_args)
        d.addCallback(render_messages)
        return server.NOT_DONE_YET
Ejemplo n.º 3
0
Archivo: web.py Proyecto: chizu/hashi
 def render_GET(self, request, session):
     def render_topic(l):
         request.write(json.dumps(l[0][0]))
         request.finish()
     topic_sql = """SELECT topic FROM channels WHERE name ILIKE %s;"""
     d = dbpool.runQuery(topic_sql, (self.name,))
     d.addCallback(render_topic)
     return server.NOT_DONE_YET
Ejemplo n.º 4
0
    def start(self):
        """Initialize the IRC client.

        Load existing configuration and join all clients."""
        start_sql = """SELECT user_email, hostname, port, ssl, nick
FROM servers JOIN server_configs ON (servers.id = server_configs.server_id)
WHERE server_configs.enabled = true;
"""
        d = dbpool.runQuery(start_sql)
        d.addCallback(self.server_init)
        return d
Ejemplo n.º 5
0
Archivo: web.py Proyecto: chizu/hashi
    def render_GET(self, request, session):
        """List of channels by default"""
        def render_channels(l):
            request.write(json.dumps(l))
            request.finish()
        chan_sql = """SELECT name FROM channels 
JOIN servers ON channels.server_id = servers.id
WHERE user_email = %s AND hostname = %s
ORDER BY name;"""
        d = dbpool.runQuery(chan_sql, (session.email,self.name));
        d.addCallback(render_channels)
        return server.NOT_DONE_YET
Ejemplo n.º 6
0
    def __init__(self, network, identity, email):
        self.network = network
        self.identity = identity
        self.email = email
        event_id_sql = """SELECT max(events.id)
FROM events
JOIN servers ON (servers.id = events.network_id)
WHERE events.observer_email = %s AND servers.hostname = %s;
"""
        # Deferred for finishing init
        self.init = dbpool.runQuery(event_id_sql, (self.email, self.network))
        def finish(l):
            self.current_id = (l[0][0] or 0)
        self.init.addCallback(finish)
Ejemplo n.º 7
0
    def signedOn(self):
        self.channels = list()
        self.publish = RemoteEventPublisher(self.network, self.nickname, self.email)
        self.publish.event("signedOn", self.nickname)
        def initial_join(l):
            for channel in l:
                self.join(channel[0], channel[1] or None)
        # Join channels
        join_sql = """SELECT name, key
FROM channels
JOIN servers ON (servers.id = channels.server_id)
WHERE enabled = true AND user_email = %s AND servers.hostname = %s;
"""
        d = dbpool.runQuery(join_sql, (self.email, self.network))
        d.addCallback(initial_join)
Ejemplo n.º 8
0
    def messageReceived(self, message):
        """Protocol is this:

        Servers control: {user} global {command} {arguments...}
        Connection control: {user} {server} {command} {arguments...}
        """
        print("Controller message: {0}".format(message))
        user, server = message[:2]
        command = message[2]
        if len(message) >= 3:
            command_args = message[3:]
        else:
            command_args = None
        subject = self.hashi.clients[user]
        # If there's a server specified, pick that server here
        if server != "global" and command != "connect":
            subject = subject[server]
        # Otherwise, the iterable subject means for all servers
        if command == 'connect':
            hostname, nick = command_args
            start_sql = """SELECT hostname, port, ssl
FROM servers WHERE hostname = %s;"""
            d = dbpool.runQuery(start_sql, (hostname,))
            d.addCallback(self.connectCallback, user, nick)
        elif command == 'join':
            # Arguments are 'channel [key]'
            subject.join(*command_args[:2])
        elif command == 'msg':
            # Arguments are 'target message ...'
            target = command_args[0]
            msg = command_args[1]
            subject.msg(target, msg, 500 - len(target))
            subject.publish.event("privmsg", subject.nickname, target, msg)
        elif command == 'action':
            target = command_args[0]
            msg = command_args[1]
            # IRCClient.me prepends # erroneously
            subject.ctcpMakeQuery(target, [('ACTION', command_args[1])])
            subject.publish.event("action", subject.nickname, target, msg)
        elif command == 'names':
            channel = command_args[0]
            subject.names(channel).addCallback(subject.got_names, channel)
Ejemplo n.º 9
0
Archivo: web.py Proyecto: chizu/hashi
    def render_GET(self, request, session):
        list_sql = """SELECT user_email, hostname, port, ssl, nick
FROM servers LEFT JOIN server_configs ON (servers.id = server_configs.server_id);"""
        d = dbpool.runQuery(list_sql)
        d.addCallback(self.list_servers, request)
        return server.NOT_DONE_YET