mod_spox 0.1.0.1 → 0.2.0

data/lib/mod_spox/Logger.rb

@@ -1,77 +1,35 @@
-require 'mod_spox/Pool'
-
+require 'logger'
 module ModSpox
 
     class Logger
-    
-        def self.do_initialization
-            Logger.fd(nil) unless Logger.class_variable_defined?(:@@fd)
-            Logger.severity unless Logger.class_variable_defined?(:@@severity)
-            @@lock = Mutex.new unless Logger.class_variable_defined?(:@@lock)
-            @@lock.synchronize do
-                @@writer = LogWriter.new(@@fd) unless Logger.class_variable_defined?(:@@writer)
-                @@initialized = true
-            end
-        end
-        
-        # severity:: minimum severity for visible logging
-        # Sets the maximum level of visible logs
-        def self.severity(severity=1)
-            @@severity = severity
-        end
-        
-        # filedes:: file descriptor to log to
-        # Sets the file descriptor for logging. By default
-        # logs will be sent to STDOUT
-        def self.fd(filedes=nil)
-            @@fd = filedes.nil? ? $stdout : filedes
-        end
-        
-        # message:: message to log
-        # severity:: severity level (lower is more severe)
-        # Log a message. It is important to note that the lower the
-        # severity level of a message, the better chance it has of
-        # being outputted
-        def self.log(message, severity=1)
-            do_initialization unless Logger.class_variable_defined?(:@@initialized)
-            @@writer.log(message) unless @@severity < severity
-        end
-        
-        def self.kill
-            @@writer.kill
-        end
-        
-    end
-    
-    class LogWriter
-    
-        attr_reader :fd
         
-        def initialize(fd)
-            @fd = fd
-            @kill = false
-            @queue = Queue.new
-            @thread = Thread.new do
-                until(@kill)
-                    processor
-                end
+        def Logger.initialize(output=nil, level=:fatal)
+            if(output.nil?)
+                @@log = nil
+            else
+                levels = {:info => Object::Logger::INFO, :warn => Object::Logger::WARN, :fatal => Object::Logger::FATAL}
+                @@log = Object::Logger.new(output)
+                @@log.level = levels.has_key?(level) ? levels[level] : Object::Logger::WARN
             end
         end
         
-        def kill
-            @kill = true
-            @queue << "Logger has been told to shut down"
+        def Logger.warn(s)
+            unless @@log.nil?
+                Pool << lambda{@@log.warn(s)}
+            end
         end
         
-        def log(message)
-            @queue << message
+        def Logger.info(s)
+            unless @@log.nil?
+                Pool << lambda{@@log.info(s)}
+            end
         end
         
-        def processor
-            message = @queue.pop
-            @fd.puts("LOGGER [#{Time.now}]: #{message}")
+        def Logger.fatal(s)
+            unless @@log.nil?
+                Pool << lambda{@@log.fatal(s)}
+            end
         end
         
     end
-    
 end

data/lib/mod_spox/MessageFactory.rb

@@ -5,27 +5,30 @@
 
 module ModSpox
 
-    class MessageFactory < Pool
-    
+    class MessageFactory
+
         # pipeline:: Message pipeline
         # Create a new MessageFactory
         def initialize(pipeline)
-            super()
             @pipeline = pipeline
             @handlers = Hash.new
-            Logger.log("Created new factory queue: #{@queue}", 15)
+            @lock = Mutex.new
             build_handlers
-            start_pool
+            @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]
         end
-        
+
         # string:: server message to be parsed
         # Parses messages from server. This is placed in a queue to
         # be processed thus there is now wait for processing to be
         # completed.
         def <<(string)
-            @queue << string
+            Pool << lambda{ parse_message(string) }
         end
-        
+
+        private
+
         # Builds the message handlers. This will load all Messages and Handlers
         # found in the lib directory and then initialize all the Handlers
         def build_handlers
@@ -35,43 +38,49 @@ module ModSpox
             Handlers.constants.each{|name|
                 klass = Handlers.const_get(name)
                 if(klass < Handlers::Handler)
-                    Logger.log("Building handler: #{name}")
+                    Logger.info("Building handler: #{name}")
                     begin
                         klass.new(@handlers)
                     rescue Object => boom
-                        Logger.log("ERROR: Failed to build handler: #{name} -> #{boom}")
+                        Logger.warn("ERROR: Failed to build handler: #{name} -> #{boom}")
                     end
                 end
             }
-            Logger.log("Handlers now available:", 15)
-            @handlers.each_pair{|k,v| Logger.log("#{k} -> #{v}", 15)}
+            Logger.info("Handlers now available:")
+            @handlers.each_pair{|k,v| Logger.info("#{k} -> #{v}")}
         end
-        
+
         # message:: server message
         # Parses the server message and passes it to the proper handler
         def parse_message(message)
-            Logger.log("Processing message: #{message}", 15)
+            Logger.info("Processing message: #{message}")
             begin
                 if(message =~ /^:\S+ (\S+)/ || message =~ /^([A-Za-z0-9]+)\s/)
                     key = $1
                     key = key.to_sym unless key[0].chr =~ /\d/
                     if(@handlers.has_key?(key))
-                        Logger.log("Message of type #{key} is now being handled by #{@handlers[key]}", 10)
-                        message = @handlers[key].process(message)
-                        @pipeline << message unless message.nil?
+                        Logger.info("Message of type #{key} is now being handled by #{@handlers[key]}")
+                        if(@sync.include?(key))
+                            Logger.info("Message of type #{key} requires synchronized processing")
+                            Pool << lambda do
+                                @lock.synchronize do
+                                    message = @handlers[key].process(message)
+                                    @pipeline << message unless message.nil?
+                                end
+                            end
+                        else
+                            Pool << lambda do
+                                message = @handlers[key].process(message)
+                                @pipeline << message unless message.nil?
+                            end
+                        end
                     end
                 end
             rescue Object => boom
-                Logger.log("Failed to parse message from server: #{boom}\n#{boom.backtrace.join("\n")}")
+                Logger.warn("Failed to parse message from server: #{boom}\n#{boom.backtrace.join("\n")}")
             end
         end
-        
-        private
-        
-        def processor
-            parse_message(@queue.pop)
-        end
-    
+
     end
 
 end

data/lib/mod_spox/Monitors.rb

@@ -72,6 +72,11 @@ module ModSpox
             def remove_thread(thread)
                 @threads.delete(thread) if @threads.include?(thread)
             end
+            
+            # Returns the number of threads currently waiting in this monitor
+            def count
+                @threads.size
+            end
         
         end
     end

data/lib/mod_spox/Pipeline.rb

@@ -4,13 +4,10 @@
  'mod_spox/Exceptions'].each{|f|require f}
 module ModSpox
 
-    class Pipeline < Pool
+    class Pipeline
 
         # Create a new Pipeline
         def initialize
-            super()
-            @timeout = 20 # Anything over 20 seconds and we assume a plugin locked up the thread
-            Logger.log("Created queue #{@queue} in pipeline", 10)
             @hooks = Hash.new
             @plugins = Hash.new
             @admin = Models::Group.filter(:name => 'admin').first
@@ -19,54 +16,53 @@ module ModSpox
             populate_signatures
             hook(self, :populate_triggers, :Internal_TriggersUpdate)
             hook(self, :populate_signatures, :Internal_SignaturesUpdate)
-            start_pool
         end
-        
+
         # message:: Message to send down pipeline
         # Queues a message to send down pipeline
         def <<(message)
-            Logger.log("Message added to pipeline queue: #{message}", 5)
-            @queue << message
+            Logger.info("Message added to pipeline queue: #{message}")
+            message_processor(message)
         end
-        
+
         # plugin:: Plugin to hook to pipeline
         # Hooks a plugin into the pipeline so it can be called
         # directly when it matches a trigger
         def hook_plugin(plugin)
-            Logger.log("Plugin #{plugin.name} hooking into pipeline", 10)
+            Logger.info("Plugin #{plugin.name} hooking into pipeline")
             @plugins[plugin.name.to_sym] = plugin
         end
-        
+
         # plugin:: Plugin to unhook from pipeline
         # Unhooks a plugin from the pipeline (This does not unhook
         # it from the standard hooks)
         def unhook_plugin(plugin)
-            Logger.log("Plugin #{plugin.name} unhooking from pipeline", 10)
+            Logger.info("Plugin #{plugin.name} unhooking from pipeline")
             @plugins.delete(plugin.name.to_sym)
             @hooks.each_pair do |type, things|
                 things.delete(plugin.name.to_sym) if things.has_key?(plugin.name.to_sym)
             end
         end
-        
+
         # plugin:: Plugin to hook to pipeline
         # method:: Plugin method pipeline should call to process message
         # type:: Type of message the plugin wants to process
         # Hooks a plugin into the pipeline for a specific type of message
         def hook(object, method, type)
-            Logger.log("Object #{object.class.to_s} hooking into messages of type: #{type}", 10)
+            Logger.info("Object #{object.class.to_s} hooking into messages of type: #{type}")
             type = type.gsub(/::/, '_').to_sym unless type.is_a?(Symbol)
             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} 
+            @hooks[type][name.to_sym] << {:object => object, :method => method}
         end
-        
+
         # plugin:: Plugin to unhook from pipeline
         # type:: Type of message the plugin no longer wants to process
         # This will remove the hook a plugin has for a specific message type
         def unhook(object, method, type)
-            Logger.log("Object #{object.class.to_s} unhooking from messages of type: #{type}", 10)
+            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
             raise Exceptions::InvalidValue.new("Unknown hook type given: #{type.to_s}") unless @hooks.has_key?(type)
@@ -77,14 +73,14 @@ module ModSpox
             @hooks[type].delete(name) if @hooks[type][name].empty
             @hooks.delete(type) if @hooks[type].empty?
         end
-        
+
         # Clears all hooks from the pipeline (Commonly used when reloading plugins)
         def clear
-            Logger.log("All hooks have been cleared from pipeline", 10)
+            Logger.info("All hooks have been cleared from pipeline")
             @hooks.clear
             @plugins.clear
         end
-        
+
         # Repopulate the active trigger list
         def populate_triggers(m=nil)
             @populate_lock.synchronize do
@@ -92,13 +88,12 @@ module ModSpox
                 Models::Trigger.filter(:active => true).each{|t|@triggers << t.trigger}
             end
         end
-        
+
         # Repopulate the active signatures list
         def populate_signatures(m=nil)
             @populate_lock.synchronize do
                 @signatures = {}
                 Models::Signature.all.each do |s|
-                    Logger.log("Signature being processed: #{s.signature}")
                     c = s.signature[0].chr.downcase
                     if(c =~ /^[a-z]$/)
                         type = c.to_sym
@@ -114,49 +109,46 @@ module ModSpox
                 end
             end
         end
-        
+
         private
-        
+
         # Processes messages
-        def processor
-            message = @queue.pop
+        def message_processor(message)
             begin
-                Logger.log("Pipeline is processing a message: #{message}", 10)
+                Logger.info("Pipeline is processing a message: #{message}")
                 parse(message)
-                type = message.class.to_s.gsub(/^ModSpox::Messages::/, '').gsub(/::/, '_').to_sym
+                type = message.class.to_s.gsub(/^(ModSpox::Messages::|#<.+?>::)/, '').gsub(/::/, '_').to_sym
                 mod = type.to_s.gsub(/_.+$/, '').to_sym
-                Logger.log("Pipeline determines that #{message} is of type: #{type}", 10)
+                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|
                             begin
-                                Timeout::timeout(@timeout) do
-                                    objects.each{|v| v[:object].send(v[:method].to_s, message) }
+                                objects.each do |v|
+                                    Pool << lambda{ v[:object].send(v[:method].to_s, message) }
                                 end
-                            rescue Timeout::Error => boom
-                                Logger.log('Timeout reached while waiting for plugin to complete task')
                             rescue Object => boom
-                                Logger.log("Plugin threw exception while attempting to process message: #{boom}\n#{boom.backtrace.join("\n")}")
+                                Logger.warn("Plugin threw exception while attempting to process message: #{boom}\n#{boom.backtrace.join("\n")}")
                             end
                         end
                     end
                 end
             rescue Object => boom
-                Logger.log("Pipeline encountered an exception while processing a message: #{boom}\n#{boom.backtrace.join("\n")}", 10)
+                Logger.warn("Pipeline encountered an exception while processing a message: #{boom}\n#{boom.backtrace.join("\n")}")
             end
         end
-        
+
         # message:: Message to parse
         # This will parse a message to see if it matches any valid
         # trigger signatures. If matches are found, they will be sent
-        # to the proper plugin for processing 
+        # to the proper plugin for processing
         def parse(message)
             return unless message.kind_of?(Messages::Incoming::Privmsg) || message.kind_of?(Messages::Incoming::Notice)
             trigger = nil
             @triggers.each{|t| trigger = t if message.message =~ /^#{Regexp.escape(t)}/}
             if(!trigger.nil? || message.addressed?)
                 return if !trigger.nil? && message.message.length == trigger.length
-                Logger.log("Message has matched against a known trigger", 15)
+                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
@@ -165,38 +157,35 @@ module ModSpox
                 else
                     type = :other
                 end
-                return unless @signatures[type]
-                @signatures[type].each do |sig|
-                    Logger.log("Matching against: #{trigger}#{sig.signature}")
+                sig_check = @signatures.has_key?(type) ? @signatures[type] : []
+                sig_check = sig_check + @signatures[:other] if type != :other && @signatures.has_key?(:other)
+                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.auth_groups.include?(sig.group) || message.source.auth_groups.include?(@admin) ||sig.group.nil?
+                        next unless message.source.auth_groups.include?(sig.group) || message.source.auth_groups.include?(@admin) || sig.group.nil?
                         next if sig.requirement == 'private' && message.is_public?
                         next if sig.requirement == 'public' && message.is_private?
                         params = Hash.new
                         sig.params.size.times do |i|
                             params[sig.params[i].to_sym] = res[0][i]
-                            Logger.log("Signature params: #{sig.params[i].to_sym} = #{res[0][i]}")
+                            Logger.info("Signature params: #{sig.params[i].to_sym} = #{res[0][i]}")
                         end
                         if(@plugins.has_key?(sig.plugin.to_sym))
                             begin
-                                Timeout::timeout(@timeout) do
-                                    @plugins[sig.plugin.to_sym].send(sig.values[:method], message, params)
-                                end
-                            rescue Timeout::Error => boom
-                                Logger.log('Timeout reached while waiting for plugin to complete task')
+                                Pool << lambda{ @plugins[sig.plugin.to_sym].send(sig.values[:method], message, params) }
                             rescue Object => boom
-                                Logger.log("Plugin threw exception while attempting to process message: #{boom}\n#{boom.backtrace.join("\n")}")
+                                Logger.warn("Plugin threw exception while attempting to process message: #{boom}\n#{boom.backtrace.join("\n")}")
                             end
                         end
                     end
                 end
             else
-                Logger.log("Message failed to match any known trigger", 15)
+                Logger.info("Message failed to match any known trigger")
             end
         end
-    
+
     end
 
 end

data/lib/mod_spox/Plugin.rb

@@ -3,22 +3,24 @@
  'mod_spox/Exceptions'].each{|f|require f}
 module ModSpox
     class Plugin
-        def initialize(pipeline)
-            raise Exceptions::BotException.new('Plugin creation failed to supply message pipeline') unless pipeline.is_a?(Pipeline)
-            @pipeline = pipeline
+        include Models
+        def initialize(args)
+            @pipeline = args[:pipeline]
+            @plugin_module = args[:plugin_module]
+            raise Exceptions::BotException.new('Plugin creation failed to supply message pipeline') unless @pipeline.is_a?(Pipeline)
             @pipeline.hook_plugin(self)
         end
-        
+
         # Called before the object is destroyed by the ModSpox::PluginManager
         def destroy
-            Logger.log("Destroy method for plugin #{name} has not been defined.", 15)
+            Logger.info("Destroy method for plugin #{name} has not been defined.")
         end
-        
+
         # Returns the name of the class
         def name
             self.class.name.to_s.gsub(/^.+:/, '')
         end
-        
+
         # target:: target for message
         # message:: string message
         # This is a helper method that will send an outgoing Privmsg
@@ -26,7 +28,7 @@ module ModSpox
         def reply(target, message)
             @pipeline << Messages::Outgoing::Privmsg.new(target, message)
         end
-        
+
         # Returns the nick model of the bot
         def me
             nick = Models::Nick.filter(:botnick => true).first
@@ -36,6 +38,35 @@ module ModSpox
                 raise Exception.new("Fatal Error: I don't know who I am.")
             end
         end
-            
+
+        # Returns constant given from plugin module. Raises ModSpox::Exceptions::InvalidType
+        # exception if constant is not found within the module
+        # Note: Use _ for depth (ie: Foo::Bar::Fee if Fee is wanted give: :Foo_Bar_Fee)
+        def plugin_const(const)
+            klass = @plugin_module
+            begin
+                const.to_s.split('_').each do |part|
+                    klass = klass.const_get(part.to_sym)
+                end
+            rescue NameError => boom
+                raise ModSpox::Exceptions::InvalidType.new("Requested constant has not been defined within the plugins module (#{const}): #{boom}")
+            end
+            if(klass.nil?)
+                raise ModSpox::Exceptions::InvalidType.new("Requested constant has not been defined within the plugins module (#{const})")
+            else
+                return klass
+            end
+        end
+        
+        def add_sig(args)
+            raise ModSpox::Exceptions::InvalidType.new('You must provide a hash for creating new signatures') unless args.is_a?(Hash)
+            sig = Signature.find_or_create(:signature => args[:sig], :plugin => name, :method => args[:method].to_s)
+            sig.description = args[:desc] if args.has_key?(:desc)
+            sig.group_id = args[:group].pk if args.has_key?(:group)
+            sig.requirement = args[:req] if args.has_key?(:req)
+            sig.params = args[:params] if args.has_key?(:params)
+            sig.save
+        end
+
     end
 end