mod_spox 0.0.1

data/lib/mod_spox/Pipeline.rb

@@ -0,0 +1,148 @@
+module ModSpox
+
+    class Pipeline < Pool
+    
+        # procs:: number of threads running in Pool
+        # Create a new Pipeline
+        def initialize(procs=3)
+            super(procs)
+            @messageq = Queue.new
+            Logger.log("Created queue #{@messageq} in pipeline", 10)
+            @hooks = Hash.new
+            @plugins = Hash.new
+            populate_triggers
+            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)
+            @messageq << 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)
+            @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 plugin", 10)
+            @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)
+            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.log("Object #{object.class.to_s} unhooking from messages of type: #{type}", 10)
+            type = type.gsub(/::/, '_').to_sym unless type.is_a?(Symbol)
+            name = object.class.gsub(/^.+:/, '').to_sym
+            raise Exception::InvalidValue.new("Unknown hook type given: #{type.to_s}") unless @hooks.has_key?(type)
+            raise Exception::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.log("All hooks have been cleared from pipeline", 10)
+            @hooks.clear
+            @plugins.clear
+        end
+        
+        def populate_triggers(m=nil)
+            @triggers = []
+            Models::Trigger.filter(:active => true).each{|t|@triggers << t.trigger}
+        end
+        
+        def populate_signatures(m=nil)
+            @signatures = []
+            Models::Signature.all.each{|s|@signatures << s}
+        end
+        
+        private
+        
+        # Processes messages
+        def processor
+            begin
+                message = @messageq.pop
+                Logger.log("Pipeline is processing a message: #{message}", 10)
+                parse(message)
+                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)
+                [type, mod, :all].each{|type|
+                    if(@hooks.has_key?(type))
+                        @hooks[type].each_value{|objects| 
+                            objects.each{|v| v[:object].send(v[:method].to_s, message) } 
+                        }
+                    end
+                } 
+            rescue Object => boom
+                Logger.log("Pipeline encountered an exception while processing a message: #{boom}\n#{boom.backtrace.join("\n")}", 10)
+            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 =~ /^#{t}/}
+            if(!trigger.nil? || message.addressed?)
+                Logger.log("Message has matched against a known trigger", 15)
+                @signatures.each{|sig|
+                    Logger.log("Matching against: #{trigger}#{sig.signature}")
+                    res = message.message.scan(/^#{trigger}#{sig.signature}$/)
+                    if(res.size > 0)
+                        next unless message.source.auth_groups.include?(sig.group) || sig.group.nil?
+                        params = Hash.new
+                        sig.params.size.times do |i|
+                            params[sig.params[i - 1].to_sym] = res[0][i]
+                            Logger.log("Signature params: #{sig.params[i - 1].to_sym} = #{res[0][i]}")
+                        end
+                        if(@plugins.has_key?(sig.plugin.to_sym))
+                            @plugins[sig.plugin.to_sym].send(sig.values[:method], message, params)
+                        end
+                    end
+                }
+            else
+                Logger.log("Message failed to match any known trigger", 15)
+            end
+        end
+    
+    end
+
+end

data/lib/mod_spox/Plugin.rb

@@ -0,0 +1,18 @@
+module ModSpox
+    class Plugin
+        def initialize(pipeline)
+            @pipeline = 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)
+        end
+        
+        # Returns the name of the class
+        def name
+            self.class.name.to_s.gsub(/^.+:/, '')
+        end
+    end
+end

data/lib/mod_spox/PluginManager.rb

@@ -0,0 +1,105 @@
+module ModSpox
+
+    class PluginManager
+    
+        # 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)
+            @plugins_module = Module.new
+            load_plugins
+        end
+        
+        # message:: Messages::Internal::PluginReload
+        # Destroys and reinitializes plugins
+        def reload_plugins(mesasge=nil)
+            unload_plugins
+            load_plugins
+        end
+        
+        # Destroys plugins
+        def destroy_plugins
+            unload_plugins
+        end
+        
+        # message:: Messages::Internal::PluginLoadRequest
+        # Loads a plugin
+        def load_plugin(message)
+            begin
+                Logger.log("THE MESSAGE NAME IS: #{message.name}")
+                path = message.name.nil? ? BotConfig[:userpluginpath] : "#{BotConfig[:userpluginpath]}/#{message.name}"
+                File.copy(message.path, path)
+                reload_plugins
+                @pipeline << Messages::Internal::PluginLoadResponse.new(message.requester, true)
+                Logger.log("Loaded new plugin: #{message.path}", 10)
+            rescue Object => boom
+                Logger.log("Failed to load plugin: #{message.path}", 10)
+                @pipeline << Messages::Internal::PluginLoadResponse.new(message.requester, false)
+            end
+        end
+        
+        # message:: Messages::Internal::PluginUnloadRequest
+        # Unloads a plugin
+        def unload_plugin(message)
+            begin
+                unless(message.name.nil?)
+                    File.copy(message.path, "#{BotConfig[:userpluginpath]}/#{message.name}")
+                end
+                File.unlink(message.path)
+                reload_plugins
+                @pipeline << Messages::Internal::PluginUnloadResponse.new(message.requester, true)
+                Logger.log("Unloaded plugin: #{message.path}", 10)
+            rescue Object => boom
+                Logger.log("Failed to unload plugin: #{message.path} Reason: #{boom}", 10)
+                @pipeline << Messages::Internal::PluginUnloadResponse.new(message.requester, false)
+            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
+        
+        private
+        
+        # Loads and initializes plugins
+        def load_plugins
+            @pipeline << Messages::Internal::TimerClear.new
+            [BotConfig[:pluginpath], BotConfig[:userpluginpath]].each{|path|
+                Dir.new(path).each{|file|
+                    if(file =~ /^[^\.].+\.rb$/)
+                        @plugins_module.module_eval(IO.readlines("#{path}/#{file}").join("\n"))
+                    end
+                }
+            }
+            @plugins_module.constants.each{|const|
+                klass = @plugins_module.const_get(const)
+                if(klass < Plugin)
+                    @plugins[const.to_sym] = klass.new(@pipeline)
+                    Logger.log("Initialized new plugin: #{const}", 15)
+                end
+            }
+            @pipeline << Messages::Internal::SignaturesUpdate.new
+        end
+        
+        # Destroys plugins
+        def unload_plugins
+            @plugins.each_pair{|sym, plugin| plugin.destroy; @pipeline.unhook_plugin(plugin)}
+            @plugins.clear
+            Models::Signature.delete_all
+            @plugins_module = Module.new
+            @pipeline << Messages::Internal::TimerClear.new
+        end
+    
+    end
+
+end

data/lib/mod_spox/Pool.rb

@@ -0,0 +1,50 @@
+module ModSpox
+
+    # The Pool class is used to reduce thread creation. When
+    # used in conjuntion with a PoolQueue, it provides an easy
+    # way to process many objects in an asynchronise manner
+    class Pool
+    
+        # num_procs:: Number of threads to use
+        # Create a new Pool
+        def initialize(num_procs=2)
+            @num_threads = num_procs
+            @threads = Array.new
+            @kill = false
+        end
+        
+        # Stop all the running threads
+        def destroy
+            @kill = true
+            @threads.each{|t|
+                Logger.log("Shutting down thread: #{t} in #{self.class.to_s}", 10)
+                t.exit
+            }
+            sleep(0.1)
+        end
+        
+        # Starts the pool
+        def start_pool
+            @num_threads.times do
+                @threads << Thread.new{
+                    until @kill do
+                        processor
+                    end
+                }
+            end
+        end
+        
+        # Method the pool uses to do stuff.
+        # (It is important to note that using this can
+        # very easily eat up all your CPU time. The Processor
+        # method must yield at some point, otherwise it will
+        # just continue to loop, even if it is doing nothing.
+        # This is the reason for the PoolQueue as this Pool
+        # was created as a way to quickly process messages)
+        def processor
+            raise Exceptions::NotImplemented.new('Processor method has not been implemented')
+        end
+    
+    end
+
+end

data/lib/mod_spox/Socket.rb

@@ -0,0 +1,171 @@
+module ModSpox
+
+    class Socket
+    
+        attr_reader :sent
+        attr_reader :received
+        attr_reader :burst
+        attr_reader :burst_in
+        attr_reader :delay
+        attr_reader :server
+        attr_reader :port
+    
+        # factory:: MessageFactory to parse messages
+        # server:: Server to connect to
+        # port:: Port number to connect to
+        # delay:: Number of seconds to delay between bursts
+        # burst_in:: Number of seconds allowed to burst
+        # burst:: Number of lines allowed to be sent within the burst_in time limit
+        # Create a new Socket
+        def initialize(bot, server, port, delay=2, burst_in=2, burst=4)
+            @factory = bot.factory
+            @pipeline = bot.pipeline
+            @server = server
+            @port = port.to_i
+            @sent = 0
+            @received = 0
+            @delay = delay.to_f > 0 ? delay.to_f : 2.0
+            @burst = burst.to_i > 0 ? burst.to_i : 4
+            @burst_in = 2
+            @kill = false
+            @reader_thread = nil
+            @writer_thread = nil
+            @time_check = nil
+            @check_burst = 0
+            @pause = false
+        end
+        
+        # Connects to the IRC server
+        def connect
+            Logger.log("Establishing connection to #{@server}:#{@port}", 10)
+            @socket = TCPSocket.new(@server, @port)
+            server = Models::Server.find_or_create(:host => @server, :port => @port)
+            server.connected = true
+            server.save
+            @sendq = Queue.new
+            Logger.log("Created new send queue: #{@sendq}", 10)
+            spooler
+            reader
+        end
+        
+        # new_delay:: Seconds to delay between bursts
+        # Resets the delay
+        def delay=(new_delay)
+            raise Exceptions::InvalidValue('Send delay must be a positive number') unless new_delay.to_f > 0
+            @delay = new_delay.to_f
+        end
+        
+        # new_burst:: Number of lines allowed in burst
+        # Resets the burst
+        def burst=(new_burst)
+            raise Exceptions::InvalidValue('Burst value must be a positive number') unless new_busrt.to_i > 0
+            @burst = new_burst
+        end
+        
+        # new_burst_in:: Number of seconds allowed to burst
+        # Resets the burst_in
+        def burst_in=(new_burst_in)
+            raise Exceptions::InvalidValue('Burst in value must be positive') unless new_burst_in.to_i > 0
+            @burst_in = new_burst_in
+        end
+        
+        # message:: String to send to server
+        # Sends a string to the IRC server
+        def puts(message)
+            write(message)
+        end
+        
+        # message:: String to send to server
+        # Sends a string to the IRC server
+        def write(message)
+            return if message.nil?
+            Logger.log("<< #{message}", 5)
+            @socket.send(message + "\n", 0)
+            @last_send = Time.new
+            @sent += 1
+            @check_burst += 1
+            @check_time = Time.now if @check_time.nil?
+        end
+        
+        # Retrieves a string from the server
+        def gets
+            read
+        end
+        
+        # Retrieves a string from the server
+        def read
+            message = @socket.gets
+            if(message.nil?)
+                @pipeline << Messages::Internal::Disconnected.new
+                shutdown
+                server = Models::Server.find_or_create(:host => @server, :port => @port)
+                server.connected = false
+                server.save
+                return
+            end
+            Logger.log(">> #{message}", 5)
+            @received += 1
+            message.strip!
+            return message
+        end
+        
+        # message:: String to be sent to server
+        # Queues a message up to be sent to the IRC server
+        def <<(message)
+            queue(message)
+        end
+        
+        # message:: String to be sent to server
+        # Queues a message up to be sent to the IRC server
+        def queue(message)
+            @sendq << message
+        end
+        
+        # Starts the thread for sending messages to the server
+        def spooler
+            @writer_thread = Thread.new{
+                until @kill do
+                    write(@sendq.pop)
+                    if((Time.now - @check_time) > @burst_in && @check_burst > @burst)
+                        sleep(@delay)
+                        @check_time = nil
+                        @check_burst = 0
+                    elsif((Time.now - @check_time) > @burst_in && @check_burst < @burst)
+                        @check_time = nil
+                        @check_burst = 0
+                    end
+                end
+            }    
+        end
+        
+        # Starts the thread for reading messages from the server
+        def reader
+            @reader_thread = Thread.new{
+                until @kill do
+                    Kernel.select([@socket], nil, nil, nil)
+                    @factory << read
+                end
+                @sendq.clear
+            }
+        end
+        
+        # restart:: Reconnect after closing connection
+        # Closes connection to IRC server
+        def shutdown(restart=false)
+            @kill = true
+            @reader_thread.join(0.1)
+            @reader_thread.kill if @reader_thread.alive?
+            @writer_thread.join(0.1)
+            @writer_thread.kill if @writer_thread.alive?
+            @reader_thread = nil
+            @writer_thread = nil
+            @socket.close
+            server = Models::Server.find_or_create(:host => @server, :port => @port)
+            server.connected = false
+            server.save
+            connect if restart
+        end
+        
+    end
+
+end

data/lib/mod_spox/Timer.rb

@@ -0,0 +1,138 @@
+module ModSpox
+
+    class Timer < Pool
+    
+        # pipeline:: message pipeline
+        # procs:: number of threads in the pool
+        # Create a new Timer
+        def initialize(pipeline, procs=2)
+            super(procs)
+            @pipeline = pipeline
+            @timers = Array.new
+            @actions = Queue.new
+            Logger.log("Created queue: #{@actions} in timer", 10)
+            @monitor = Monitors::Timer.new
+            @thread = nil
+            @stop_timer = false
+            {:Internal_TimerAdd => :add_message,
+             :Internal_TimerRemove => :remove_message}.each_pair{|type,method|
+                @pipeline.hook(self, method, type)
+            }
+            start_pool
+        end
+        
+        # Wakes the timer up early
+        def wakeup
+            Logger.log("Timer has been explicitly told to wakeup", 15)
+            @monitor.wakeup unless @thread.nil?
+        end
+        
+        # message:: TimerAdd message
+        # Add a recurring code block
+        def add_message(message)
+            Logger.log("New block is being added to the timer", 15)
+            action = add(message.period, message.once, message.data, &message.block)
+            begin
+                @pipeline << Messages::Internal::TimerResponse.new(message.requester, action, true)
+                Logger.log("New block was successfully added to the timer", 15)
+            rescue Object => boom
+                Logger.log("Failed to add block to timer: #{boom}", 10)
+                @pipeline << Messages::Internal::TimerResponse.new(message.requester, action, false)
+            end
+        end
+        
+        # message:: TimerRemove message
+        # Remove an action from the timer
+        def remove_message(message)
+            remove(message.action)
+            Logger.log("Action has been removed from the Timer", 15)
+            @pipeline << Messages::Internal::TimerResponse.new(nil, message.action, false)
+        end
+        
+        # period:: seconds between running action
+        # once:: only run action once
+        # data:: data to be available
+        # &func:: data block to run
+        # Adds a new action to the timer
+        def add(period, once=false, data=nil, &func)
+            action = Action.new(self, period, data, once, &func)
+            @timers << action
+            wakeup
+            return action
+        end
+        
+        # action:: Action to add to timer's queue
+        # Adds a new action to the timer        
+        def add_action(action)
+            raise Exceptions::InvalidType.new('An Action object must be supplied') unless action.is_a?(Action)
+            @timers << action
+            wakeup
+        end
+        
+        # action:: Action to remove from timer's queue
+        # Removes and action from the timer
+        def remove(action)
+            raise Exceptions::InvalidType.new('An Action object must be supplied') unless action.is_a?(Action)
+            @timers.delete(action)
+            wakeup
+        end
+        
+        # Starts the timer
+        def start
+            raise Exceptions::AlreadyRunning.new('Timer is already running') unless @thread.nil?
+            @thread = Thread.new{
+                until @stop_timer do
+                    to_sleep = nil
+                    @timers.each do |a|
+                        to_sleep = a.remaining if to_sleep.nil?
+                        to_sleep = a.remaining if !a.remaining.nil? && a.remaining < to_sleep
+                    end
+                    Logger.log("Timer is set to sleep for #{to_sleep.nil? ? 'forever' : "#{to_sleep} seconds"}", 15)
+                    actual_sleep = @monitor.wait(to_sleep)
+                    tick(actual_sleep)
+                    Logger.log("Timer was set to sleep for #{to_sleep.nil? ? 'forever' : "#{to_sleep} seconds"} seconds. Actual sleep time: #{actual_sleep} seconds", 15)
+                end
+            }
+        end
+        
+        # Stops the timer
+        def stop
+            raise Exceptions::NotRunning.new('Timer is not running') if @thread.nil?
+            @stop_timer = true
+            wakeup
+            @thread.join
+        end
+        
+        # Clears all actions in the timer's queue
+        def clear
+            @actions.clear
+            @timers.clear
+        end
+        
+        private
+        
+        # time_passed:: time passed since last tick
+        # Decrements all Actions the given amount of time
+        def tick(time_passed)
+            for action in @timers do
+                action.tick(time_passed)
+                if(action.due?)
+                    @actions << action.schedule
+                end
+            end
+        end
+        
+        # Process the actions
+        def processor
+            action = @actions.pop
+            begin
+                action.run
+                remove(action) if action.is_complete?
+            rescue Object => boom
+                Logger.log("Timer block generated an exception: #{boom}\n#{boom.backtrace.join("\n")}", 5)
+            end
+        end
+    
+    end
+    
+end

data/lib/mod_spox/handlers/BadNick.rb

@@ -0,0 +1,16 @@
+module ModSpox
+    module Handlers
+        class BadNick < Handler
+            def initialize(handlers)
+                handlers[ERR_ERRONEOUSNICKNAME] = self
+            end
+            def process(string)
+                if(string =~ /#{RPL_ERRORNEOUSNICK}\s\S+\s(\S+)\s:/)
+                    return Messages::Incoming::BadNick.new(string, $1)
+                else
+                    Logger.log('Failed to process RPL_ERRORONEOUSNICK message')
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Bounce.rb

@@ -0,0 +1,15 @@
+module ModSpox
+    module Handlers
+        class Bounce < Handler
+            def initialize(handlers)
+                handlers[RPL_BOUNCE] = self
+            end
+            
+            def process(string)
+                if(string =~ /:Try server (\S+), port (.+)$/)
+                    return Messages::Incoming::Bounce.new(string, $1, $2)
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Created.rb

@@ -0,0 +1,16 @@
+module ModSpox
+    module Handlers
+        class Created < Handler
+            def initialize(handlers)
+                handlers[RPL_CREATED] = self
+            end
+            def process(string)
+                if(string =~ /#{RPL_CREATED.to_s}.+?:created\s(.+)$/)
+                    return Messages::Incoming::Created(string, $1)
+                else
+                    Logger.log('Failed to parse RPL_CREATED message')
+                end
+            end
+        end
+    end
+end