spox-mod_spox 0.3.1 → 0.3.2

data/lib/mod_spox/FilterManager.rb

@@ -0,0 +1,63 @@
+module ModSpox
+    class FilterManager
+        
+        def initialize(pipeline)
+            @pipeline = pipeline
+            @filters = {}
+            [:FilterAdd, :FilterRemove, :FilterList, :FilterListing].each{|f| Helpers.load_message(:internal, f)}
+            @pipeline.hook(self, :add_filter, ModSpox::Messages::Internal::FilterAdd)
+            @pipeline.hook(self, :remove_filter, ModSpox::Messages::Internal::FilterRemove)
+            @pipeline.hook(self, :list_filter, ModSpox::Messages::Internal::FilterList)
+        end
+        
+        # filter:: ModSpox::Filter object
+        # type:: type of message to filter
+        def add(filter, type)
+            type = Helpers.find_const(type)
+            @filters[type] ||= []
+            @filters[type] << filter
+        end
+        
+        # filter:: ModSpox::Filter object
+        # type:: type of message filter is associated to
+        # Remove a filter. If a type is defined, the filter
+        # will only be removed from that type. If no type is
+        # defined, the filter will be removed completely
+        def remove(filter, type=nil)
+            if(type.nil?)
+                @filters.each do |ar|
+                    ar.delete_if do |key, value|
+                        value == filter
+                    end
+                end
+            else
+                type = Helpers.find_const(type)
+                if(@filters[type])
+                    key = @filters[type].index(filter)
+                    @filters[type].delete(key) if key
+                end
+            end
+        end
+        
+        # type:: type of message
+        # Return array of filters. Will only return
+        def filters(type=nil)
+            if(type.nil?)
+                return @filters.dup
+            else
+                type = Helpers.find_const(type)
+                return @filters[type] ? @filters[type].dup : nil
+            end
+        end
+
+        # m:: message from pipeline
+        # Applies filters to messages from pipeline
+        def apply_filters(m)
+            @filters.keys.each do |type|
+                if(Helpers.type_of?(m, type))
+                    @filters[type].each{|f| f.filter(m)}
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/Helpers.rb

@@ -11,8 +11,8 @@ module ModSpox
         # secs:: number of seconds
         # Converts seconds into a human readable string
         def Helpers.format_seconds(secs)
-            arg = {:year => 29030400,
-                   :month => 2419200,
+            arg = {:year => 31536000,
+                   :month => 2678400,
                    :week => 604800,
                    :day => 86400,
                    :hour => 3600,
@@ -44,29 +44,37 @@ module ModSpox
         "Yotta"   # 1024^8
         ]
         def Helpers.format_size(bytes)
+            return "0 bytes" if bytes == 0
             mag = (Math.log(bytes) / Math.log(1024)).floor
             mag = [ Suff.length - 1, mag ].min
             val = bytes.to_f / (1024 ** mag)
-            "%7.3f %sbyte%s" % [ val, Suff[mag], val == 1 ? "" : "s" ]
+            ("%.3f %sbyte%s" % [ val, Suff[mag], val == 1 ? "" : "s" ]).strip
         end
 
         # command:: command to execute
         # timeout:: maximum number of seconds to run
+        # maxbytes:: maximum number of result bytes to accept
         # Execute a system command (use with care)
-        def Helpers.safe_exec(command, timeout=10)
+        def Helpers.safe_exec(command, timeout=10, maxbytes=500)
+            output = []
+            pro = nil
             begin
                 Timeout::timeout(timeout) do
-                    result = `#{command}`
+                    pro = IO.popen(command)
+                    until(pro.closed? || pro.eof?)
+                        output << pro.getc
+                        raise IOError.new("Maximum allowed output bytes exceeded. (#{maxbytes} bytes)") unless output.count <= maxbytes
+                    end
                 end
-            rescue Timeout::Error => boom
-                Logger.warn("Command execution exceeded allowed time (command: #{command} | timeout: #{timeout})")
-                raise boom
+                output = output.join('')
             rescue Object => boom
-                Logger.warn("Command generated an exception (command: #{command} | error: #{boom})")
                 raise boom
+            ensure
+                Process.kill('KILL', pro.pid) if Process.waitpid2(pro.pid, Process::WNOHANG).nil? # make sure the process is dead
             end
+            return output
         end
-
+        
         # url:: URL to shorten
         # Gets a tinyurl for given URL
         def Helpers.tinyurl(url)
@@ -87,13 +95,13 @@ module ModSpox
         # or channel name. If the string given does not match the required
         # pattern for a channel or nick, the string is returned.
         def Helpers.find_model(string, create=true)
-            result = nil
+            result = string
             if(string =~ /^[A-Za-z\|\\\{\}\[\]\^\`~\_\-]+[A-Za-z0-9\|\\\{\}\[\]\^\`~\_\-]*$/)
                 result = Models::Nick.find_or_create(:nick => string.downcase)
             elsif(['&', '#', '+', '!'].include?(string[0]))
                 result = Models::Channel.find_or_create(:name => string.downcase)
-            elsif(Models::Server.filter(:host => string, :connected => true).count > 0)
-                result = Models::Server.filter(:host => string, :connected => true).first
+            elsif(Models::Server.filter(:host => string).count > 0)
+                result = Models::Server.filter(:host => string).first
             else
                 Logger.warn("Failed to match string to model: #{string} -> No match")
             end
@@ -115,8 +123,106 @@ module ModSpox
         # kind:: (:internal|:incoming|:outgoing)
         # type:: message type (Example: :Privmsg)
         # Easy loader for messages
-        def load_message(kind, type)
+        def Helpers.load_message(kind, type)
+            raise ArgumentError.new('Valid kind types: :internal, :incoming, :outgoing') unless [:internal, :incoming, :outgoing].include?(kind)
             require "mod_spox/messages/#{kind}/#{type}"
         end
+
+        # a:: object
+        # b:: type constant or string
+        # symbolize:: Symbolize and check (deprecated)
+        # Determines if a is a type of b. For example:
+        # 
+        #   a = Foo::Bar.new
+        #   Helpers.type_of?(a, Foo) -> true
+        def Helpers.type_of?(a, b, symbolize=false)
+            return true if (b.is_a?(Class) || b.is_a?(Module)) && a.is_a?(b) # if only it were always this easy
+            checks = []
+            # first, we strip the front down
+            t = a.class.to_s
+            unless(t.index('ModSpox::Messages::').nil?)
+                t.slice!(t.index('ModSpox::Messages::'), 19)
+                checks << t
+            end
+            t = a.class.to_s
+            if(t.slice(0) == '<')
+                t.slice!(0, t.rindex('>'))
+                checks << t
+            end
+            checks << a.class.to_s
+            checks.each do |s|
+                until(s.index('::').nil?) do
+                    s.slice!(s.rindex('::'), s.length - s.rindex('::'))
+                    return true if s =~ /#{b}.*/
+                end
+            end
+            # one last check if we are allowed to symbolize
+            if(symbolize && b.is_a?(Symbol))
+                sym = a.class.to_s
+                sym.gsub!('::', '_')
+                return true if sym == b || b =~ /#{sym}.*/
+                sym.slice!(0, 17) if sym.index('ModSpox_Messages') == 0
+                sym.slice!(0, sym.index('>')+1) if sym.index('<') == 0 # this is for dynamic objects from plugins
+                return true if sym == b || b =~ /#{sym}.*/
+            end
+            return false
+        end
+        
+        # c:: constant name (String)
+        # Finds a constant if it exists
+        # Example:: Foo::Bar
+        def Helpers.find_const(c)
+            return c unless c.is_a?(String)
+            const = nil
+            [Kernel, ModSpox, Messages].each do |base|
+                begin
+                    c.split('::').each do |part|
+                        const = const.nil? ? base.const_get(part) : const.const_get(part)
+                    end
+                rescue NameError
+                    const = nil
+                end
+            end
+            return const.nil? ? c : const
+        end
+        
+        # IdealHumanRandomIterator - select "random" members of a population, favoring
+        # those least-recently selected, to appease silly humans who hate repeats
+        #
+        # Abstract:
+        # given a decently-sized set of items (say, 100 famous quotes), an
+        # average persons's idea of N "random" entries is not actually random.
+        # people don't want items to appear twice in a row, or too frequently
+        # (even though true randomness means this is just as likely as any other order).
+        #
+        # instead, design a scheme whereby LRU items are weighted more heavily,
+        # to "encourage" subsequent selections to not repeat.
+        #
+        # Author: Ryan "pizza_" Flynn
+        # - pulled from the algodict project
+        # - - http://github.com/pizza/algodict
+        class IdealHumanRandomIterator
+
+            def initialize(list)
+                raise ArgumentError.new("Array type required") unless list.is_a?(Array)
+                @items = list
+            end
+
+            # Given length L, generate a random number in the range [0,len-1), heavily
+            # weighted towards the low end.
+            def self.nexti(len)
+                len += 1 if len % 2 == 1
+                index = len > 2 ? rand(len/2) : 0
+                return index
+            end
+
+            # return a psuedo-random member of items. subsequent calls should never
+            # return the same item.
+            def next()
+                index = IdealHumanRandomIterator.nexti(@items.length)
+                @items.push @items.delete_at(index)
+                return @items.last
+            end
+        end
     end
 end

data/lib/mod_spox/Loader.rb

@@ -38,7 +38,7 @@ module ModSpox
                     Database.db = Sequel.connect("#{ModSpox.jdbc ? 'jdbc:' : ''}postgres://#{config[:db_username]}:#{config[:db_password]}@#{config[:db_host]}/#{config[:db_database]}")
                     Database.type = :pgsql
                 when 'sqlite'
-                    Database.db = Sequel.sqlite("#{BotConfig[:userpath]}/mod_spox.db", :pool_timeout => 20, :timeout => 5000)
+                    Database.db = Sequel.connect("#{ModSpox.jdbc ? 'jdbc:' : ''}sqlite://#{BotConfig[:userpath]}/mod_spox.db", :pool_timeout => 20, :timeout => 5000)
                     Database.type = :sqlite
             end
         end

data/lib/mod_spox/MessageFactory.rb

@@ -21,6 +21,13 @@ module ModSpox
             @sync = [:RPL_MOTDSTART, :RPL_MOTD, :RPL_ENDOFMOTD, :RPL_WHOREPLY, :RPL_ENDOFWHO,
                      :RPL_NAMREPLY, :RPL_ENDOFNAMES, :RPL_WHOISUSER, :RPL_WHOISSERVER, :RPL_WHOISOPERATOR,
                      :RPL_WHOISIDLE, :RPL_WHOISCHANNELS, :RPL_WHOISIDENTIFIED, :RPL_ENDOFWHOIS].map{|s| RFC[s][:value]}
+            @pipeline.hook(self, :proc_internal, ModSpox::Messages::Internal::Incoming)
+        end
+
+        # m:: ModSpox::Messages::Internal::Incoming
+        # Process internal raw message
+        def proc_internal(m)
+            self << m.message
         end
 
         # string:: server message to be parsed
@@ -76,10 +83,10 @@ module ModSpox
                         end
                     end
                 else
-                    Logger.error("No handler was found to process message of type: #{key} Message: #{message}")
+                    Logger.warn("No handler was found to process message of type: #{key} Message: #{message}")
                     raise Exceptions::HandlerNotFound.new(key)
                 end
-            rescue Exceptions::HandlerNotFound => boom
+            rescue ModSpox::Exceptions::HandlerNotFound => boom
                 unless(loaded)
                     if(@available[boom.message_type])
                         @available[boom.message_type].each do|f|
@@ -96,6 +103,7 @@ module ModSpox
                         retry
                     end
                 end
+                Logger.error("Failed to find a handler for: #{boom.message_type}")
                 raise boom
             rescue Object => boom
                 if(boom.class.to_s == 'SQLite3::BusyException' || boom.class.to_s == 'PGError')

data/lib/mod_spox/Pipeline.rb

@@ -2,7 +2,8 @@
  'mod_spox/Logger',
  'mod_spox/Exceptions',
  'mod_spox/messages/incoming/Privmsg',
- 'mod_spox/messages/incoming/Notice'].each{|f|require f}
+ 'mod_spox/messages/incoming/Notice',
+ 'mod_spox/FilterManager'].each{|f|require f}
 module ModSpox
 
     class Pipeline
@@ -16,8 +17,9 @@ module ModSpox
             @populate_lock = Mutex.new
             populate_triggers
             populate_signatures
-            hook(self, :populate_triggers, :Internal_TriggersUpdate)
-            hook(self, :populate_signatures, :Internal_SignaturesUpdate)
+            hook(self, :populate_triggers, ModSpox::Messages::Internal::TriggersUpdate)
+            hook(self, :populate_signatures, ModSpox::Messages::Internal::SignaturesUpdate)
+            @filters = FilterManager.new(self)
         end
 
         # message:: Message to send down pipeline
@@ -52,12 +54,12 @@ module ModSpox
         # Hooks a plugin into the pipeline for a specific type of message
         def hook(object, method, type)
             Logger.info("Object #{object.class.to_s} hooking into messages of type: #{type}")
-            type = type.gsub(/::/, '_').to_sym unless type.is_a?(Symbol)
+            type = Helpers.find_const(type)
             method = method.to_sym unless method.is_a?(Symbol)
-            name = object.class.to_s.gsub(/^.+:/, '')
-            @hooks[type] = Hash.new unless @hooks.has_key?(type)
-            @hooks[type][name.to_sym] = Array.new unless @hooks[type][name.to_sym].is_a?(Array)
-            @hooks[type][name.to_sym] << {:object => object, :method => method}
+            name = object.class
+            @hooks[type] ||= Hash.new
+            @hooks[type][name] ||= Array.new
+            @hooks[type][name] << {:object => object, :method => method}
         end
 
         # plugin:: Plugin to unhook from pipeline
@@ -65,8 +67,8 @@ module ModSpox
         # This will remove the hook a plugin has for a specific message type
         def unhook(object, method, type)
             Logger.info("Object #{object.class.to_s} unhooking from messages of type: #{type}")
-            type = type.gsub(/::/, '_').to_sym unless type.is_a?(Symbol)
-            name = object.class.to_s.gsub(/^.+:/, '').to_sym
+            type = Helpers.find_const(type)
+            name = object.class
             raise Exceptions::InvalidValue.new("Unknown hook type given: #{type.to_s}") unless @hooks.has_key?(type)
             raise Exceptions::InvalidValue.new("Unknown object hooked: #{name.to_s}") unless @hooks[type].has_key?(name)
             @hooks[type][name].each{|hook|
@@ -100,7 +102,7 @@ module ModSpox
                 a.destroy
                 Models::Signature.all.each do |s|
                     c = s.signature[0].chr.downcase
-                    if(c =~ /^[a-z]$/)
+                    if(c =~ /^[A-Za-z]$/)
                         type = c.to_sym
                     elsif(c =~ /^[0-9]$/)
                         type = :digit
@@ -119,39 +121,26 @@ module ModSpox
 
         # Processes messages
         def message_processor(message)
-            begin
-                Logger.info("Pipeline is processing a message: #{message}")
-                parse(message)
-                type = message.class.to_s.gsub(/^(ModSpox::Messages::|#<.+?>::)/, '').gsub('::', '_').to_sym
-                mod = type.to_s.gsub(/_.+$/, '').to_sym
-                Logger.info("Pipeline determines that #{message} is of type: #{type}")
-                [type, mod, :all].each do |type|
-                    if(@hooks.has_key?(type))
-                        @hooks[type].each_value do |objects|
+            @filters.apply_filters(message)
+            return if message.nil?
+            @hooks.keys.each do |type|
+                next unless Helpers.type_of?(message, type, true)
+                @hooks[type].each_value do |objects|
+                    objects.each do |v|
+                        @pool.process do
                             begin
-                                objects.each do |v|
-                                    @pool.process do
-                                        begin
-                                            v[:object].send(v[:method].to_s, message)
-                                        rescue Object => boom
-                                            if(boom.class.to_s == 'SQLite3::BusyException')
-                                                Database.reset_connections
-                                                retry
-                                            else
-                                                raise boom
-                                            end
-                                        end
-                                    end
-                                end
+                                v[:object].send(v[:method], message)
                             rescue Object => boom
-                                Logger.warn("Plugin threw exception while attempting to process message: #{boom}\n#{boom.backtrace.join("\n")}")
+                                if(boom.class.to_s == 'SQLite3::BusyException')
+                                    Database.reset_connections
+                                end
+                                raise boom
                             end
                         end
                     end
                 end
-            rescue Object => boom
-                Logger.warn("Pipeline encountered an exception while processing a message: #{boom}\n#{boom.backtrace.join("\n")}")
             end
+            parse(message)
         end
 
         # message:: Message to parse
@@ -159,49 +148,65 @@ module ModSpox
         # trigger signatures. If matches are found, they will be sent
         # to the proper plugin for processing
         def parse(message)
-            return unless message.kind_of?(Messages::Incoming::Privmsg) || message.kind_of?(Messages::Incoming::Notice)
+            return unless message.is_a?(Messages::Incoming::Privmsg) || message.is_a?(Messages::Incoming::Notice)
             trigger = nil
             @triggers.each{|t| trigger = t if message.message[0..t.size-1] == t}
-            if(!trigger.nil? || message.addressed?)
-                return if !trigger.nil? && message.message.length == trigger.length
-                Logger.info("Message has matched against a known trigger")
-                c = (message.addressed? && trigger.nil?) ? message.message[0].chr.downcase : message.message[trigger.length].chr.downcase
-                if(c =~ /^[a-z]$/)
-                    type = c.to_sym
-                elsif(c =~ /^[0-9]$/)
-                    type = :digit
-                else
-                    type = :other
+            unless(trigger.nil? && !message.addressed?)
+                return if trigger && message.message.length == trigger.length
+                Logger.info('Messages has matched a known trigger')
+                # okay, so now that we know we are being asked to do something, lets find
+                # a signature that might match. Signatures are sorted by first character
+                # so once we have that we can get rolling
+                c = (message.addressed? && trigger.nil?) ? message.message[0].chr : message.message[trigger.length].chr
+                case c
+                    when /[A-Za-z]/
+                        type = c.to_sym
+                    when /\d/
+                        type = :digit
+                    else
+                        type = :other
                 end
-                sig_check = @signatures.has_key?(type) ? @signatures[type] : []
-                sig_check = sig_check + @signatures[:other] if type != :other && @signatures.has_key?(:other)
+                sig_check = @signatures[type] ? @signatures[type] : []
+                sig_check += @signatures[:other] if @signatures[:other] && type != :other # others are always checked because they are fickle shells of what they once were
                 sig_check.each do |sig|
                     Logger.info("Matching against: #{trigger}#{sig.signature}")
                     esc_trig = trigger.nil? ? '' : Regexp.escape(trigger)
-                    res = message.message.scan(/^#{esc_trig}#{sig.signature}$/)
-                    if(res.size > 0)
-                        next unless message.source.in_group?(sig.group) || message.source.in_group?(@admin) || sig.group.nil?
-                        next if sig.requirement == 'private' && message.is_public?
-                        next if sig.requirement == 'public' && message.is_private?
+                    result = message.message.scan(/^#{esc_trig}#{sig.signature}$/)
+                    if(result.size > 0 && @plugins[sig.plugin.to_sym])
+                        next unless allowed?(message, sig)
                         params = Hash.new
+                        # symbolize up the parameters for symbolic symbolism
                         sig.params.size.times do |i|
-                            params[sig.params[i].to_sym] = res[0][i]
-                            Logger.info("Signature params: #{sig.params[i].to_sym} = #{res[0][i]}")
+                            params[sig.params[i].to_sym] = result[0][i]
+                            Logger.info("Signature params: #{sig.params[i]} = #{result[0][i]}")
                         end
-                        if(@plugins.has_key?(sig.plugin.to_sym))
+                        # throw it in the pool for processing
+                        @pool.process do
                             begin
-                                @pool.process{ @plugins[sig.plugin.to_sym].send(sig.values[:method], message, params) }
+                                @plugins[sig.plugin.to_sym].send(sig.values[:method], message, params)
                             rescue Object => boom
-                                Logger.warn("Plugin threw exception while attempting to process message: #{boom}\n#{boom.backtrace.join("\n")}")
+                                if(boom.class.to_s == 'SQLite3::BusyException')
+                                    Database.reset_connections
+                                end
+                                raise boom
                             end
                         end
                     end
                 end
             else
-                Logger.info("Message failed to match any known trigger")
+                Logger.info('Message failed to match any known trigger')
             end
         end
 
+        # message:: ModSpox::Messages::Incoming
+        # sig:: ModSpox::Models::Signature
+        # Check if the given message is allowed to be processed
+        def allowed?(message, sig)
+            return false if sig.requirement == 'private' && message.is_public?
+            return false if sig.requirement == 'public' && message.is_private?
+            return (message.source.in_group?(sig.group) || message.source.in_group?(@admin) || sig.group.nil?)
+        end
+
     end
 
 end