spox-mod_spox 0.3.1 → 0.3.2

data/CHANGELOG

@@ -1,3 +1,8 @@
+0.3.2 (Alpha status)
+    Core:
+    * New tests resulting in lots of bug fixing
+    * New and untested/documented message filtering
+    
 0.3.1 Release (Alpha status)
     Core:
     * As needed class loading

data/README.rdoc

@@ -6,6 +6,65 @@ The core of mod_spox is basically a framework for interacting with IRC. By itsel
 
 The framework provided by mod_spox allows it to quickly transform from a useless bag of bytes to something entertaining, annoying, helpful, and aggravating, occasionally all at the same time. This transformation is accomplished through the use of plugins which use the framework to accomplish feats of greatness.
 
+Included with mod_spox are a variety of plugins to help make the bot a bit more interesting.
+
+* Authenticator - Authenticate users for running commands
+* Banner - Pattern matching bans. Timed bans. Ban accumulation. 
+* BotNick - Sends nick information to the server
+* Helper - Provide help on various plugins
+* Initializer - Gets the bot all ready on startup
+* Joiner - Join a channel
+* Nicker - Change the bot's nick
+* Parter - Part a channel
+* Permissions - Change permissions on triggers
+* PluginLoader - Load and unload plugins
+* Ponger - Send PONG replies
+* Quitter - Quit
+* Servers - Server configuration
+* Status - Show bot status and version information
+* Triggers - Show, add, remove triggers
+
+Wow. So many amazing plugins that some how seem to make the bot even more boring than it was when it was completely useless. Fear not, for there are a variety of optional plugins designed to strip the boring and replace it with rainbows and unicorns.
+
+* AOLSpeak - Speak in AOL. Kick in AOL.
+* AutoKick - Kick/Ban based on message pattern matching
+* AutoMode - Automatically set nicks +o or +v
+* AutoRejoin - Rejoin channel on KICK or connection automatically
+* Bash - Grab a bash.org quote
+* Bullshit - Spout bullshit
+* Bytes - Convert bytes to human readable
+* Confess - Show confessions
+* DevWatch - Report changes on a trac timeline
+* DownForEveryoneOrJustMe - Check if a site is down
+* EightBall - Let mod_spox answer life's most difficult questions
+* FML - Assurance that life could be worse
+* Fortune - Random fortunes from fortune files
+* GoogleIt - Perform search for people who are unable
+* Headers - Show headers from a given site
+* Karma - Tally the karma of things. 
+* Locator - Locate a nick
+* Logger - Log a channel
+* LolSpeak - Translate text to LOL
+* NickServ - Identify with NickServ
+* PhpCli - Execute PHP code
+* PhpFuncLookup - Lookup and display PHP functions
+* Pinger - Send pong reply to nick
+* Quotes - Store channel quotes
+* RegexTracker - Track how often a pattern appears in channel
+* Roulette - Ask mod_spox to shoot you
+* RubyCli - Execute Ruby code
+* Search - Search the web for terms
+* Seen - Keep sighting log of nicks
+* SlashdotHeadlineGenerator - Generate Slashdot headlines
+* Slashdot - Show current Slashdot headlines
+* Talk - Make mod_spox talk
+* Topten - Current chattiest people
+* TracTicket - Add new tickets to trac
+* Translate - Translate text. Also provides automatic translation
+* Twitter - Display status message of twits to channel
+* UrbanDictionary - The only dictionary that matters on IRC
+* Weather - Show the weather
+
 == Critical informations
 
 * Author: spox <spox@rubyforge.org>
@@ -15,7 +74,8 @@ The framework provided by mod_spox allows it to quickly transform from a useless
 
 == Aquiring
 
-* Gem:    gem install mod_spox
+Gem:
+    gem install mod_spox
 
 == Aquiring current unstable
 

data/bin/mod_spox

@@ -60,17 +60,11 @@ opts.each do |opt, arg|
             puts '--help -h:                          print this help message'
             exit
         when '--version'
-            puts "mod_spox IRC bot version: #{$BOTVERSION}"
+            puts "mod_spox IRC bot version: #{ModSpox.botversion}"
             puts 'http://rubyforge.org/projects/modspox'
             exit
         when '--jdbc'
             ModSpox.jdbc = true
-            begin
-                require 'jdbc/postgres'
-            rescue Object => boom
-                puts 'Failed to load JDBC Postgres gem'
-                exit 1
-            end
         when '--debug'
             if(arg && arg.gsub(' ', '').size > 0)
                 ModSpox.logto = arg

data/data/mod_spox/extras/AutoKick.rb

@@ -4,6 +4,7 @@ class AutoKick < ModSpox::Plugin
 
     def initialize(pipeline)
         super
+        Helpers.load_message(:incoming, :Privmsg)
         group = Group.find_or_create(:name => 'autokick')
         add_sig(:sig => 'autokick list', :method => :list, :group => group, :desc => 'List active autokick rules')
         add_sig(:sig => 'autokick add (#\S+) (\d+) (\S+) (.+)', :method => :add, :group => group, :desc => 'Add new autokick rule for current channel', :req => 'public', :params => [:channel, :time, :regex, :message])
@@ -108,7 +109,7 @@ class AutoKick < ModSpox::Plugin
     def do_listen
         @map = nil
         begin
-            @pipeline.unhook(self, :listener, :Incoming_Privmsg)
+            @pipeline.unhook(self, :listener, ModSpox::Messages::Incoming::Privmsg)
         rescue Object => boom
             #ignore
         end
@@ -119,7 +120,7 @@ class AutoKick < ModSpox::Plugin
                 @map[record.channel_id] = [] unless @map[record.channel_id]
                 @map[record.channel_id] << record.pattern
             end
-            @pipeline.hook(self, :listener, :Incoming_Privmsg)
+            @pipeline.hook(self, :listener, ModSpox::Messages::Incoming::Privmsg)
         end
     end
 

data/data/mod_spox/extras/AutoMode.rb

@@ -14,7 +14,8 @@ class AutoMode < ModSpox::Plugin
         add_sig(:sig => 'automode list (\S+)', :method => :list, :group => @admin, :desc => 'Show list of current auto-modes for channel', :params => [:channel])
         add_sig(:sig => 'delmode (\S+)', :method => :remove, :group => @admin, :desc => 'Remove nick from any auto-modes in channel', :req => 'public', :params => [:nick])
         ModeRecord.create_table unless ModeRecord.table_exists?
-        @pipeline.hook(self, :check_join, :Incoming_Join)
+        Helpers.load_message(:incoming, :Join)
+        @pipeline.hook(self, :check_join, ModSpox::Messages::Incoming::Join)
     end
     
     def addop(m, p)

data/data/mod_spox/extras/AutoRejoin.rb

@@ -4,10 +4,11 @@ class AutoRejoin < ModSpox::Plugin
 
     def initialize(pipeline)
         super
-        @pipeline.hook(self, :check_kick, :Incoming_Kick)
-        @pipeline.hook(self, :check_join, :Incoming_Join)
-        @pipeline.hook(self, :check_part, :Incoming_Part)
-        @pipeline.hook(self, :do_joins, :Incoming_Welcome)
+        [:Kick, :Join, :Part, :Welcome].each{|t| Helpers.load_message(:incoming, t)}
+        @pipeline.hook(self, :check_kick, ModSpox::Messages::Incoming::Kick)
+        @pipeline.hook(self, :check_join, ModSpox::Messages::Incoming::Join)
+        @pipeline.hook(self, :check_part, ModSpox::Messages::Incoming::Part)
+        @pipeline.hook(self, :do_joins, ModSpox::Messages::Incoming::Welcome)
     end
     
     def check_kick(message)

data/data/mod_spox/extras/Bouncer.rb

@@ -1,69 +1,95 @@
 require 'openssl'
 
+## config stuffs: port
+
 class Bouncer < ModSpox::Plugin
 
+    # Setup our plugin
     def initialize(pipeline)
         super
         bounce = Group.find_or_create(:name => 'bouncer')
-        add_sig(:sig => 'bouncer port( (\d+))?', :method => :port, :group => bounce, :desc => 'Show or set bouncer port',
-            :params => [:port])
-        add_sig(:sig => 'bouncer (start|stop|restart)', :method => :do_service, :group => bounce, :desc => 'Start, stop, or restart bouncer')
+        add_sig(:sig => 'bouncer port( (\d+))?', :method => :set_port, :group => bounce, :desc => 'Show or set bouncer port', :params => [:port])
+        add_sig(:sig => 'bouncer (start|stop|restart)', :method => :do_service, :group => bounce, :desc => 'Start, stop, or restart bouncer', :params => [:action])
         add_sig(:sig => 'bouncer status', :method => :status, :group => bounce, :desc => 'Show current bouncer status')
-        add_sig(:sig => 'bouncer disconnect', :method => :disconnect, :group => bounce, :desc => 'Disconnect all connected clients')
-        add_sig(:sig => 'bouncer clients'< :method => :clients, :group => bounce, :desc => 'List clients connected to bouncer')
-        @pipeline.hook(self, :get_msgs, :Incoming)
-        @listener = nil
-        @clients = []
-        @socket = nil
-        @processor = nil
-        @to_server = Queue.new
-        start_listener if Models::Config.filter(:name => 'bouncer_port').count > 0
+        add_sig(:sig => 'bouncer disconnect', :method => :do_disconnect, :group => bounce, :desc => 'Disconnect all connected clients')
+        add_sig(:sig => 'bouncer clients', :method => :clients, :group => bounce, :desc => 'List clients connected to bouncer')
+        add_sig(:sig => 'bouncer generate cert', :method => :certgen, :group => bounce, :desc => 'Generate new certification')
+        @pipeline.hook(self, :get_msgs, ModSpox::Messages::Incoming)
+        @spockets = Spockets::Spockets.new
+        @listener_thread = nil
+        @listener_socket = nil
+        @clients = {}
+        Helpers.load_message(:outgoing, :Raw)
+        Helpers.load_message(:internal, :Incoming)
+        @filters = {}
+        methods.each do |f|
+            f = f.to_s
+            z = f.slice!(0..6)
+            @filters[f.to_sym] = (z+f).to_sym if z == 'filter_'
+        end
+        start_listener unless port.nil?
+    end
+
+    # Clean up our socket stuffs
+    def destroy
+        stop_listener
+        disconnect
+    end
+
+    # m:: message
+    # params:: parameters
+    # Set/show current listening port
+    def set_port(m, params)
+        begin
+            if(params[:port])
+                params[:port] = params[:port].to_i
+                port(params[:port])
+                information m.replyto, "Bouncer port has been updated to: #{params[:port] == 0 ? 'disabled' : params[:port].to_s}"
+                warning m.replyto, 'Bouncer must be restarted for port to be changed' if running?
+            else
+                if(port)
+                    information m.replyto, "Bouncer is set to listen on port: #{port}"
+                else
+                    warning m.replyto, "Bouncer port has not been set"
+                end
+            end
+        rescue Object => boom
+            error m.replyto, "Failed to update bouncer port. Reason: #{boom}"
+        end
     end
     
+    # message:: ModSpox::Messages::Incoming types
+    # Get all incoming messages to pass on to clients
     def get_msgs(message)
         unless(@clients.empty?)
             Logger.info("Bouncer has #{@clients.size} clients to send a message to")
-            @clients.each do |client|
+            @clients.keys.each do |client|
                 begin
                     output = message.raw_content.is_a?(Array) ? message.raw_content.join("\n") : message.raw_content + "\n"
-                    client[:connection].puts(output)
+                    client.puts(output)
                 rescue Object => boom
                     Logger.warn("Bouncer encountered unexpected error. Disconnecting client. #{boom}")
-                    client[:thread].kill if client[:thread].alive?
-                    @clients.delete(client)
+                    disconnect(client)
                 end
             end
         end
     end
-    
-    def port(m, params)
-        if(params[:port])
-            if(Models::Config.filter(:name => 'bouncer_port').count > 0)
-                reply m.replyto, "Bouncer port is set to: #{Models::Config.filter(:name => 'bouncer_port').first.value
-            else
-                error m.replyo, 'No port has been set for bouncer'
-            end
-        else
-            parmas[:port].strip!
-            c = Models::Config.find_or_create(:name => 'bouncer_port')
-            c.value = params[:port]
-            c.save
-            information m.replyto, "Bouncer port is not set to: #{params[:port]}"
-        end
-    end
-    
+
+    # m:: message
+    # params:: parameters
+    # Start/stop/restart bouncer
     def do_service(m, params)
         begin
             case params[:action]
             when 'start'
-                if(listening?)
+                if(running?)
                     error m.replyto, 'Bouncer is already running'
                 else
                     start_listener
                     information m.replyto, 'Bouncer has been started'
                 end
             when 'stop'
-                if(listening?)
+                if(running?)
                     stop_listener
                     information m.replyto, 'Bouncer has been stopped'
                 else
@@ -79,141 +105,227 @@ class Bouncer < ModSpox::Plugin
         end
     end
 
-    def disconnect(m, params)
+    # m:: message
+    # params:: parameters
+    # Disconnect all clients from bouncer
+    # TODO: add individual disconnects
+    def do_disconnect(m, params)
         unless(@clients.empty?)
-            @clients.each do |client|
-                client[:connection].close unless client[:connection].closed?
-                @clients.delete(client)
-            end
+            disconnect
             information m.replyto, 'All clients have been disconnected'
         else
             warning m.replyto, 'No clients are connected to bouncer'
         end
     end
-    
+
+    # m:: message
+    # params:: parameters
+    # Display current bot status
     def status(m, params)
-        warning m.replyto, 'not implemented'
+        information m.replyto, "Status: #{running? ? 'listening' : 'stopped'}"
     end
-
-    private
     
-    def start_listener
-        port = Models::Config.filter(:name => 'bouncer_port').first
-        raise 'Port has not been set' unless port
-        port = port.value.to_i
-        @socket = OpenSSL::SSL::SSLServer.new(port)
-        @listener = Thread.new do
-            until(@socket.closed?)
-                begin
-                    new_con = @socket.accept_nonblock
-                    add_client(new_con)
-                rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINTR
-                        IO.select([@socket])
-                        retry
-                rescue Object => boom
-                    Logger.warn "Bouncer listener encountered an error: #{boom}"
-                end
-            end
+    # m:: message
+    # params:: parameters
+    # Generate a new certificate
+    def certgen(m, params)
+        begin
+            create_certs
+            information m.replyto, 'New certificate has been generated'
+        rescue Object
+            error m.replyto, "Failed to create new certificate: #{boom}"
         end
     end
-    
-    def add_client
+
+    private
+
+    # Generates an OpenSSL::SSL::SSLContext
+    def generate_ctx
+        c = Models::Setting.filter(:name => 'bouncer_ssl').first
+        sc = nil
+        if(c)
+            cert = c.value
+            sc = OpenSSL::SSL::SSLContext.new
+            sc.key = OpenSSL::PKey::RSA.new(cert[:key])
+            sc.cert = OpenSSL::X509::Certificate.new(cert[:cert])
+        else
+            create_certs
+            sc = generate_ctx
+        end
+        return sc
     end
 
-class Bouncer < ModSpox::Plugin
-    
-    def status(message, params)
+    # Generates and stores new key and certificate
+    def create_certs
+        Logger.info('Generating key/cert pair for bouncer SSL')
+        key = OpenSSL::PKey::RSA.new(2048)
+        cert = OpenSSL::X509::Certificate.new
+        cert.not_before = Time.now
+        cert.not_after = Time.now + 99999999
+        cert.public_key = key.public_key
+        cert.sign(key, OpenSSL::Digest::SHA1.new)
+        c = Models::Setting.find_or_create(:name => 'bouncer_ssl')
+        c.value = {:cert => cert.to_s, :key => key.to_s}
+        c.save
     end
-    
-    private
-    
+
+    # Starts the listener for new connections
     def start_listener
-        port = Config[:bouncer_port]
-        if(port)
-            @socket = TCPServer.new(port)
+        raise 'Port has not been set' if port.nil?
+        begin
+            @socket = OpenSSL::SSL::SSLServer.new(TCPServer.new(port), generate_ctx)
             @listener = Thread.new do
-                until(@socket.closed?)
+                until(@socket.closed?) do
                     begin
-                        new_con = @socket.accept_nonblock
-                        Logger.info("BOUNCER: New connection established on bouncer")
-                        @clients << {
-                                    :connection => new_con, 
-                                    :thread => Thread.new(new_con) do | con |
-                                        begin
-                                        Logger.info("CONNECTION: #{con}")
-                                        until(con.closed?)
-                                            Logger.info("WAITING FOR STUFF ON :#{con}")
-                                            Kernel.select([con], nil, nil, nil)
-                                            Logger.info("Woken up and ready to read")
-                                            string = con.gets
-                                            Logger.info("BOUNCER GOT MESSAGE: #{string}")
-                                            if(string.empty?)
-                                                raise Exception.new("EMPTY STRING")
-                                            else
-                                                @to_server << {:message => string, :socket => con}
-                                            end
-                                        end
-                                        rescue Object => boom
-                                        Logger.warn("THREAD BOUNCER ERROR: #{boom}")
-                                        end
-                                        end
-                                    }
-                    rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINTR
-                        IO.select([@socket])
+                        new_con = @socket.accept
+                        add_client(new_con)
+                    rescue Object => boom
+                        Logger.warn "Bouncer listener encountered an error: #{boom}"
                         retry
                     end
                 end
                 @listener = nil
             end
-            start_processor
-        else
-            Logger.warn("Error: Bouncer was not started. Failed to find set port number")
+        rescue Object => boom
+            Logger.error "Bouncer listener encountered an error: #{boom}"
+            raise boom
         end
     end
-    
-    def stop_listener
-        @socket.close
-        @listener.kill unless @listener.nil?
-        @listener = nil
-        @to_server.clear
-        @processor.kill if !@processor.nil? && @processor.alive?
-        @processor = nil
+
+    # socket:: SSLSocket
+    # Adds a new client to the bouncer
+    def add_client(socket)
+        @clients[socket] = {:nick => false, :user => false, :init => false}
+        @spockets.add(socket) do |string|
+            deliver_message(string, socket)
+        end
     end
-    
-    def start_processor
-        @processor.kill if !@processor.nil? && @processor.alive?
-        @processor = Thread.new do
+
+    # string:: outgoing string
+    # socket:: SSLSocket that sent the string
+    # Delivers messages from clients to the IRC
+    # server
+    def deliver_message(string, socket)
+        Logger.info("Processing bouncer message: #{string} for socket: #{socket}")
         begin
-            while(@listener) do
-                info = @to_server.pop
-                Logger.info("Processing message: #{info[:message]}")
-                if(info[:message] =~ /^USER\s/i)
-                    initialize_connection(info[:socket])
+            unless(@clients[socket][:init])
+                part = string.slice(0,5)
+                Logger.info "Part we extracted: #{part}|"
+                @clients[socket][:nick] = true if part == 'NICK '
+                @clients[socket][:user] = true if part == 'USER '
+                if(@clients[socket][:nick] && @clients[socket][:user])
+                    initialize_connection(socket)
+                    @clients[socket][:init] = true
                 else
-                    @pipeline << Messages::Outgoing::Raw.new(info[:message])
+                    Logger.warn("Got part: #{part}. Not init yet")
                 end
+            else
+                filter(string, socket)
             end
         rescue Object => boom
-            Logger.warn("BOUNCER ERROR: #{boom}")
-            unless(@clients.empty?)
-                @clients.each do |socket|
-                    socket[:connection].close
-                    @clients.delete(socket)
-                end
-            end
+            Logger.error("Bouncer received message but failed to pass it on. Error: #{boom} Message: #{string}")
         end
+    end
+
+    # Stops the listener
+    def stop_listener
+        @socket.close
+        @listener.kill unless @listener.nil?
+        @listener = nil
+        @socket = nil
+    end
+
+    # socket:: SSLSocket
+    # Disconnect given socket or all sockets
+    def disconnect(socket=nil)
+        sockets = socket.nil? ? @clients.keys : [socket]
+        sockets.each do |sock|
+            begin
+                @spockets.remove(sock)
+            rescue Spockets::UnknownSocket => boom
+                Logger.warn('Socket was already removed automatically from spockets')
+            end
+            sock.close
+            @clients.delete(sock)
         end
     end
-    
-    def listening?
+
+    # Returns if the listener is running
+    def running?
         return !@listener.nil?
     end
     
+    # connection:: SSLSocket
+    # Sends initialization information to client. Basically a
+    # 001 welcome message and JOINs for any channels the bot is in
     def initialize_connection(connection)
         # send channel info and such to client
         connection.puts(":localhost 001 #{me.nick} :Welcome to the network #{me.source}\n")
-        Models::Channel.filter(:parked => true).each do |channel|
-            connection.puts(":#{me.source} JOIN :#{channel.name}\n")
+        me.channels.each do |channel|
+            connection.puts(":#{me.source} JOIN :#{channel.name}")
+        end
+    end
+
+    # num:: integer
+    # Set/show port number for listener
+    def port(num=nil)
+        if(num.nil?)
+            conf = Models::Config.filter(:name => 'bouncer_port').first
+            return conf ? conf.value : nil
+        else
+            if(num == 0)
+                Models::Config.filter(:name => 'bouncer_port').destroy
+            else
+                raise 'Invalid port number' if num < 1 || num > 65535
+                conf = Models::Config.find_or_create(:name => 'bouncer_port')
+                conf.value = num
+                conf.save
+            end
+        end
+    end
+
+    # string:: Outgoing string
+    # socket:: SSLSocket
+    # f:: filter to call. Defaults to running all filters
+    # Filter outgoing string to be delivered to IRC server. This
+    # is used to stop excessive WHO/PING type messages from flooding
+    # the server and getting the bot kicked.
+    def filter(string, socket, f=:all)
+        if(f == :all)
+            @filters.each{|f| send(@filters[f], string, socket)}
+        else
+            raise NoMethodError.new unless @filters[f]
+            send(@filters[f], string, socket)
+        end
+        unless(string.empty?)
+            @pipeline << Messages::Outgoing::Raw.new(string)
+            Logger.warn("Modifying message-> :#{me.source} #{string}")
+            @pipeline << Messages::Internal::Incoming.new(":#{me.source} #{string}") if string.slice(0, 7).downcase == 'privmsg'
+        end
+    end
+
+    ## Filters are here ##
+
+    def filter_who(string, socket)
+        if(string.slice(0..2).downcase == 'who')
+            nick = string.slice(4, string.size-3)
+            if(nick.downcase == m.nick.downcase)
+                #send who info
+                string.delete!(string)
+            end
+        end
+    end
+
+    def filter_quit(string, socket)
+        if(string.slice(0..3).downcase == 'quit')
+            string.delete!(string)
+        end
+    end
+
+    def filter_ping(string, socket)
+        if(string.slice(0..3).downcase == 'ping')
+            socket.puts(":mod_spox.bouncer PONG mod_spox.bouncer :#{string.slice(5, string.size - 4)}")
+            string.delete!(string)
         end
     end