spox-mod_spox 0.3.1

data/lib/mod_spox/Pipeline.rb

@@ -0,0 +1,207 @@
+['mod_spox/models/Models.rb',
+ 'mod_spox/Logger',
+ 'mod_spox/Exceptions',
+ 'mod_spox/messages/incoming/Privmsg',
+ 'mod_spox/messages/incoming/Notice'].each{|f|require f}
+module ModSpox
+
+    class Pipeline
+
+        # Create a new Pipeline
+        def initialize(pool)
+            @pool = pool
+            @hooks = Hash.new
+            @plugins = Hash.new
+            @admin = Models::Group.filter(:name => 'admin').first
+            @populate_lock = Mutex.new
+            populate_triggers
+            populate_signatures
+            hook(self, :populate_triggers, :Internal_TriggersUpdate)
+            hook(self, :populate_signatures, :Internal_SignaturesUpdate)
+        end
+
+        # message:: Message to send down pipeline
+        # Queues a message to send down pipeline
+        def <<(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.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.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.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}
+        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.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)
+            raise Exceptions::InvalidValue.new("Unknown object hooked: #{name.to_s}") unless @hooks[type].has_key?(name)
+            @hooks[type][name].each{|hook|
+                @hooks[type][name].delete(hook) if hook[:method] == method
+            }
+            @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.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
+                @triggers = []
+                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 = {}
+                a = Models::Signature.filter(:enabled => false)
+                Logger.warn("Killing #{a.count} signatures")
+                a.destroy
+                Models::Signature.all.each do |s|
+                    c = s.signature[0].chr.downcase
+                    if(c =~ /^[a-z]$/)
+                        type = c.to_sym
+                    elsif(c =~ /^[0-9]$/)
+                        type = :digit
+                    else
+                        type = :other
+                    end
+                    @signatures[type] = [] unless @signatures[type]
+                    unless @signatures.include?(s)
+                        @signatures[type] << s
+                    end
+                end
+            end
+        end
+
+        private
+
+        # 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|
+                            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
+                            rescue Object => boom
+                                Logger.warn("Plugin threw exception while attempting to process message: #{boom}\n#{boom.backtrace.join("\n")}")
+                            end
+                        end
+                    end
+                end
+            rescue Object => boom
+                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
+        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[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
+                end
+                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.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?
+                        params = Hash.new
+                        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]}")
+                        end
+                        if(@plugins.has_key?(sig.plugin.to_sym))
+                            begin
+                                @pool.process{ @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")}")
+                            end
+                        end
+                    end
+                end
+            else
+                Logger.info("Message failed to match any known trigger")
+            end
+        end
+
+    end
+
+end

data/lib/mod_spox/Plugin.rb

@@ -0,0 +1,97 @@
+['mod_spox/Pipeline',
+ 'mod_spox/Logger',
+ 'mod_spox/Exceptions',
+ 'mod_spox/messages/outgoing/Privmsg'].each{|f|require f}
+module ModSpox
+    class Plugin
+        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.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
+        # to the given target
+        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
+            if(nick)
+                return nick
+            else
+                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
+        
+        # Adds a new signature for the given plugin
+        # Required args: :sig and :method
+        # Optional args: :group, :req, :desc, and :params
+        def add_sig(args)
+            raise ModSpox::Exceptions::InvalidType.new('You must provide a hash for creating new signatures') unless args.is_a?(Hash)
+            args[:params] = nil unless args[:params]
+            sig = Signature.find_or_create(:signature => args[:sig], :plugin => name, :method => args[:method].to_s,
+                                            :params => args[:params], :group_id => args[:group].nil? ? nil : args[:group].pk)
+            sig.description = args[:desc] if args.has_key?(:desc)
+            sig.requirement = args[:req] if args.has_key?(:req)
+            sig.save
+        end
+        
+        # to:: Where message is going
+        # message:: message
+        # Send an information message to target
+        def information(to, message)
+            reply to, "\2#{name} (info):\2 #{message}"
+        end
+        
+        # to:: Where message is going
+        # message:: message
+        # Send an warning message to target
+        def warning(to, message)
+            reply to, "\2#{name} (warn):\2 #{message}"
+        end
+        
+        # to:: Where message is going
+        # message:: message
+        # Send an error message to target
+        def error(to, message)
+            reply to, "\2#{name} (error):\2 #{message}"
+        end
+
+    end
+end

data/lib/mod_spox/PluginHolder.rb

@@ -0,0 +1,22 @@
+module ModSpox
+    # Holder for plugin
+    class PluginHolder
+        # Create a new holder with a plugin
+        def initialize(plugin)
+            @plugin = plugin
+            @lock = Mutex.new
+        end
+        # plugin:: Plugin to set into this holder
+        def set_plugin(plugin)
+            @lock.synchronize do
+                @plugin = plugin
+            end
+        end
+        # Returns the plugin this holder contains
+        def plugin
+            @lock.synchronize do
+                return @plugin
+            end
+        end
+    end
+end

data/lib/mod_spox/PluginManager.rb

@@ -0,0 +1,257 @@
+['fileutils',
+ 'mod_spox/Logger',
+ 'mod_spox/Pipeline',
+ 'mod_spox/models/Models',
+ 'mod_spox/messages/Messages',
+ 'mod_spox/Plugin',
+ 'mod_spox/PluginHolder',
+ 'mod_spox/Exceptions',
+ 'mod_spox/messages/internal/QueueSocket',
+ 'mod_spox/messages/internal/UnqueueSocket',
+ 'mod_spox/messages/internal/PluginLoadResponse',
+ 'mod_spox/messages/internal/SignaturesUpdate',
+ 'mod_spox/messages/internal/PluginUnloadResponse',
+ 'mod_spox/messages/internal/PluginModuleResponse',
+ 'mod_spox/messages/internal/PluginResponse',
+ 'mod_spox/messages/internal/TimerClear',
+ 'mod_spox/messages/internal/PluginsReady'].each{|f|require f}
+ 
+module ModSpox
+
+    class PluginManager
+
+        include Exceptions
+
+        # Hash of plugins. Defined by class name symbol (i.e. Trivia class: plugins[:Trivia])
+        attr_reader :plugins
+
+        # pipeline:: Pipeline for messages
+        # Create new PluginManager
+        def initialize(pipeline)
+            @plugins = Hash.new
+            @pipeline = pipeline
+            @pipeline.hook(self, :load_plugin, :Internal_PluginLoadRequest)
+            @pipeline.hook(self, :unload_plugin, :Internal_PluginUnloadRequest)
+            @pipeline.hook(self, :reload_plugins, :Internal_PluginReload)
+            @pipeline.hook(self, :send_modules, :Internal_PluginModuleRequest)
+            @pipeline.hook(self, :plugin_request, :Internal_PluginRequest)
+            @plugins_module = Module.new
+            @plugin_lock = Mutex.new
+            load_plugins
+        end
+
+        # message:: Messages::Internal::PluginReload
+        # Destroys and reinitializes plugins
+        def reload_plugins(message=nil)
+            @pipeline << Messages::Internal::QueueSocket.new
+            begin
+                @plugin_lock.synchronize do
+                    if(!message.nil? && (message.fresh && message.stale))
+                        do_unload(message.stale)
+                        FileUtils.remove_file(message.stale)
+                        FileUtils.copy(message.fresh, BotConfig[:userpluginpath])
+                        do_load(message.stale)
+                        Logger.info("Completed reload of plugin: #{message.stale}")
+                    else
+                        unload_plugins
+                        load_plugins
+                    end
+                end
+            rescue Object => boom
+                Logger.error("PluginManager caught error on plugin reload: #{boom}")
+            ensure
+                @pipeline << Messages::Internal::UnqueueSocket.new
+            end
+        end
+
+        # Destroys plugins
+        def destroy_plugins
+            unload_plugins
+        end
+
+        # message:: Messages::Internal::PluginLoadRequest
+        # Loads a plugin
+        def load_plugin(message)
+            @pipeline << Messages::Internal::QueueSocket.new
+            begin
+                path = !message.name ? "#{BotConfig[:userpluginpath]}/#{message.path.gsub(/^.+\//, '')}" : "#{BotConfig[:userpluginpath]}/#{message.name}"
+                begin
+                    File.symlink(message.path, path)
+                rescue NotImplementedError => boom
+                    FileUtils.copy(message.path, path)
+                end
+                do_load(path)
+                @pipeline << Messages::Internal::PluginLoadResponse.new(message.requester, true)
+                Logger.info("Loaded new plugin: #{message.path}")
+            rescue Object => boom
+                Logger.warn("Failed to load plugin: #{message.path} Reason: #{boom}")
+                @pipeline << Messages::Internal::PluginLoadResponse.new(message.requester, false)
+            ensure
+                @pipeline << Messages::Internal::SignaturesUpdate.new
+                @pipeline << Messages::Internal::UnqueueSocket.new
+            end
+        end
+
+        # message:: Messages::Internal::PluginUnloadRequest
+        # Unloads a plugin
+        def unload_plugin(message)
+            @pipeline << Messages::Internal::QueueSocket.new
+            begin
+                do_unload(message.path)
+                unless(File.symlink?(message.path))
+                    unless(message.name.nil?)
+                        FileUtils.copy(message.path, "#{BotConfig[:userpluginpath]}/#{message.name}")
+                    end
+                end
+                File.delete(message.path)
+                @pipeline << Messages::Internal::PluginUnloadResponse.new(message.requester, true)
+                Logger.info("Unloaded plugin: #{message.path}")
+            rescue Object => boom
+                Logger.warn("Failed to unload plugin: #{message.path} Reason: #{boom}")
+                @pipeline << Messages::Internal::PluginUnloadResponse.new(message.requester, false)
+            ensure
+                @pipeline << Messages::Internal::UnqueueSocket.new
+                @pipeline << Messages::Internal::SignaturesUpdate.new
+            end
+        end
+
+        # message:: Messages::Internal::PluginModuleRequest
+        # Sends the plugins module to the requester
+        def send_modules(message)
+            @pipeline << Messages::Internal::PluginModuleResponse.new(message.requester, @plugins_module)
+        end
+
+        # message:: Messages::Internal::PluginRequest
+        # Returns a plugin to requesting object
+        def plugin_request(message)
+            if(@plugins.has_key?(message.plugin))
+                response = Messages::Internal::PluginResponse.new(message.requester, @plugins[message.plugin])
+            else
+                response = Messages::Internal::PluginResponse.new(message.requester, nil)
+            end
+            @pipeline << response
+        end
+
+        def upgrade_plugins
+            @plugins[:PluginLoader].plugin.extras_upgrade
+        end
+
+        private
+
+        # Loads and initializes plugins
+        def load_plugins
+            @pipeline << Messages::Internal::TimerClear.new
+            Models::Signature.set(:enabled => false)
+            [BotConfig[:pluginpath], BotConfig[:userpluginpath]].each do |path|
+                Dir.new(path).each do |file|
+                    if(file =~ /^[^\.].+\.rb$/)
+                        begin
+                            do_load("#{path}/#{file}")
+                        rescue Object => boom
+                            Logger.warn("Failed to load file: #{path}/#{file}. Reason: #{boom}")
+                        end
+                    end
+                end
+            end
+            @pipeline << Messages::Internal::SignaturesUpdate.new
+            @pipeline << Messages::Internal::PluginsReady.new
+        end
+
+        # Destroys plugins
+        def unload_plugins
+            @plugins.each_pair do |sym, holder|
+                begin
+                    holder.plugin.destroy unless holder.plugin.nil?
+                    @pipeline.unhook_plugin(holder.plugin)
+                rescue Object => boom
+                    Logger.warn("Plugin destruction error: #{boom}")
+                end
+            end
+            @plugins_module = Module.new
+            @pipeline << Messages::Internal::TimerClear.new
+        end
+
+        # path:: path to plugin file
+        # Loads a plugin into the plugin module
+        def do_load(path)
+            if(File.exists?(path))
+                plugins = discover_plugins(path)
+                raise PluginMissing.new("Plugin file at: #{path} does not contain a plugin class") if plugins.nil?
+                @plugins_module.module_eval(IO.readlines(path).join("\n"))
+                begin
+                    plugins.each do |plugin|
+                        klass = @plugins_module.const_get(plugin)
+                        if(@plugins.has_key?(plugin.to_sym))
+                            @plugins[plugin.to_sym].set_plugin(klass.new({:pipeline => @pipeline, :plugin_module => @plugins_module}))
+                        else
+                            @plugins[plugin.to_sym] = PluginHolder.new(klass.new({:pipeline => @pipeline, :plugin_module => @plugins_module}))
+                        end
+                        Logger.info("Properly initialized new plugin: #{plugin}")
+                        Database.reset_connections
+                    end
+                    Logger.info("All plugins found at: #{path} have been loaded")
+                rescue Object => boom
+                    Logger.warn("Plugin loading failed: #{boom}\n#{boom.backtrace.join("\n")}")
+                    Logger.warn("All constants loaded from file: #{path} will now be unloaded")
+                    do_unload(path)
+                end
+            else
+                raise PluginFileNotFound.new("Failed to find file at: #{path}")
+            end
+        end
+
+        # path:: path to plugin file
+        # Unloads a plugin and all constants from the plugin module
+        def do_unload(path)
+            if(File.exists?(path))
+                discover_plugins(path).each do |plugin|
+                    if(@plugins.has_key?(plugin.to_sym))
+                        @plugins[plugin.to_sym].plugin.destroy unless @plugins[plugin.to_sym].plugin.nil?
+                        @pipeline.unhook_plugin(@plugins[plugin.to_sym].plugin)
+                        @plugins[plugin.to_sym].set_plugin(nil)
+                        @pipeline << Messages::Internal::TimerClear.new(plugin.to_sym)
+                    end
+                    Models::Signature.filter(:plugin => plugin.to_s).destroy
+                end
+                discover_consts(path).each do |const|
+                    Logger.info("Removing constant: #{const}")
+                    @plugins_module.send(:remove_const, const)
+                end
+                Logger.info("Removed all constants found in file: #{path}")
+            else
+                raise PluginFileNotFound.new("Failed to find file at: #{path}")
+            end
+        end
+
+        # path:: path to plugin
+        # Find class names of any plugins within the file at given path
+        def discover_plugins(path)
+            temp = Module.new
+            begin
+                temp.module_eval(IO.readlines(path).join("\n"))
+                klasses = []
+                temp.constants.each do |const|
+                    klass = temp.const_get(const)
+                    klasses << const if klass < Plugin
+                end
+                return klasses
+            rescue Object => boom
+                return nil
+            end
+        end
+
+        # path:: path to plugin
+        # Find all constant names in given path
+        def discover_consts(path)
+            temp = Module.new
+            begin
+                temp.module_eval(IO.readlines(path).join("\n"))
+                return temp.constants
+            rescue Object => boom
+                return nil
+            end
+        end
+
+    end
+
+end

data/lib/mod_spox/PriorityQueue.rb

@@ -0,0 +1,69 @@
+module ModSpox
+    # This class provides some simple logic for message output. It
+    # is basically a priority based queue with some round robin
+    # thrown in, just to keep things interesting. This queue provides
+    # protection on message output from extreme lag to one target when
+    # another target is expecting large quantities out output
+    # NOTE: Design help from the great Ryan "pizza_" Flynn
+    class PriorityQueue
+    
+        # Create a priority queue
+        def initialize
+            @target_queues = {}
+            @queues = {:PRIORITY => Queue.new, :NEW => Queue.new, :NORMAL => Queue.new, :WHOCARES => Queue.new}
+            @lock = Mutex.new
+        end
+        
+        # target:: message target (targets starting with * will be labelled WHOCARES
+        # message:: message to send
+        # This prioritizes output to help reduce lag when lots of output
+        # is being sent to another target. This will automatically decide
+        # how to queue the message based on the target
+        def priority_queue(target, message)
+            @lock.synchronize do
+                target.downcase!
+                @target_queues[target] = Queue.new unless @target_queues[target]
+                if(target[0].chr == '*')
+                    @target_queues[target] << message
+                    @queues[:WHOCARES] << @target_queues[target]
+                else
+                    @target_queues[target] << message
+                    if(@target_queues[target].size < 2)
+                        @queues[:NEW] << @target_queues[target]
+                    else
+                        @queues[:NORMAL] << @target_queues[target]
+                    end
+                end
+            end
+        end
+        
+        # message:: message to send
+        # This will add messages to the PRIORITY queue which gets
+        # sent before all other messages.
+        def direct_queue(message)
+            @lock.synchronize do
+                @target_queues[:general] = Queue.new unless @target_queues[:general]
+                @target_queues[:general] << message
+                @queues[:PRIORITY] << @target_queues[:general]
+            end
+        end
+        
+        # Returns the next message to send. This method decides what
+        # message to send based on the priority of the message. It
+        # will throw an Exceptions::EmptyQueue when there are no messages
+        # left.
+        def pop
+            m = nil
+            @lock.synchronize do
+                [:PRIORITY, :NEW, :NORMAL, :WHOCARES].each do |k|
+                    unless(@queues[k].empty?)
+                        m = @queues[k].pop.pop
+                        break
+                    end
+                end
+            end
+            raise Exceptions::EmptyQueue.new if m.nil?
+            return m
+        end
+    end
+end