mod_spox 0.0.4 → 0.0.5

data/lib/mod_spox/Logger.rb

@@ -1,6 +1,18 @@
+require 'mod_spox/Pool'
+
 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
@@ -21,9 +33,43 @@ module ModSpox
         # severity level of a message, the better chance it has of
         # being outputted
         def self.log(message, severity=1)
-            Logger.fd(nil) unless Logger.class_variable_defined?(:@@fd)
-            Logger.severity unless Logger.class_variable_defined?(:@@severity)
-            @@fd.puts("LOGGER [#{Time.now}]: #{message}") unless @@severity < severity
+            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
+            end
+        end
+        
+        def kill
+            @kill = true
+            @queue << "Logger has been told to shut down"
+        end
+        
+        def log(message)
+            @queue << message
+        end
+        
+        def processor
+            message = @queue.pop
+            @fd.puts("LOGGER [#{Time.now}]: #{message}")
         end
         
     end

data/lib/mod_spox/MessageFactory.rb

@@ -1,3 +1,8 @@
+['mod_spox/handlers/Handler',
+ 'mod_spox/Logger',
+ 'mod_spox/Pipeline',
+ 'mod_spox/Pool'].each{|f|require f}
+
 module ModSpox
 
     class MessageFactory < Pool

data/lib/mod_spox/Monitors.rb

@@ -12,7 +12,13 @@ module ModSpox
             
             # Force the monitor to wake everyone up
             def wakeup
-                @threads.each{|t|t.wakeup}
+                @threads.each do |t|
+                    begin
+                        t.wakeup
+                    rescue Object => boom
+                        # thread was dead #
+                    end
+                end
                 @threads.clear
             end
             
@@ -40,24 +46,20 @@ module ModSpox
             # Stop waiting
             def wakeup
                 return if @threads.empty?
-                @threads.each do |thread|
-                    if(thread.status == 'sleep')
-                        Logger.log("Sending wakeup for thread: #{thread}", 5)
-                        thread.run
-                        Logger.log("Status of thread to wakeup: #{thread.status}", 5)
-                        Logger.log("Calling thread is: #{Thread.current}", 5)
-                    else
-                        Logger.log("Thread to wakeup has been killed: #{thread}")
+                @threads.each do |t|
+                    begin
+                        t.wakeup
+                    rescue Object => boom
+                        # thread was dead #
                     end
-                    @threads.delete(thread)
                 end
+                @threads.clear
             end
             
             # Start waiting
             def wait
                 @threads << Thread.current
-                Logger.log("Stopping execution of thread: #{Thread.current}", 5)
-                Thread.stop
+                sleep
             end
             
             # Returns if a thread is currently waiting in this monitor

data/lib/mod_spox/Pipeline.rb

@@ -1,3 +1,7 @@
+['mod_spox/models/Models.rb',
+ 'mod_spox/Logger',
+ 'mod_spox/Pool',
+ 'mod_spox/Exceptions'].each{|f|require f}
 module ModSpox
 
     class Pipeline < Pool
@@ -10,6 +14,7 @@ module ModSpox
             @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)
@@ -36,7 +41,7 @@ module ModSpox
         # 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)
+            Logger.log("Plugin #{plugin.name} unhooking from pipeline", 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)
@@ -82,14 +87,32 @@ module ModSpox
         
         # Repopulate the active trigger list
         def populate_triggers(m=nil)
-            @triggers = []
-            Models::Trigger.filter(:active => true).each{|t|@triggers << t.trigger}
+            @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)
-            @signatures = []
-            Models::Signature.all.each{|s|@signatures << s}
+            @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
+                    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
@@ -133,7 +156,16 @@ module ModSpox
             @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 do |sig|
+                c = message.addressed? ? message.message[0].chr.downcase : message.message[1].chr.downcase
+                if(c =~ /^[a-z]$/)
+                    type = c.to_sym
+                elsif(c =~ /^[0-9]$/)
+                    type = :digit
+                else
+                    type = :other
+                end
+                return unless @signatures[type]
+                @signatures[type].each do |sig|
                     Logger.log("Matching against: #{trigger}#{sig.signature}")
                     res = message.message.scan(/^#{trigger}#{sig.signature}$/)
                     if(res.size > 0)

data/lib/mod_spox/Plugin.rb

@@ -1,3 +1,6 @@
+['mod_spox/Pipeline',
+ 'mod_spox/Logger',
+ 'mod_spox/Exceptions'].each{|f|require f}
 module ModSpox
     class Plugin
         def initialize(pipeline)

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

@@ -1,4 +1,10 @@
-require 'fileutils'
+['fileutils',
+ 'mod_spox/Logger',
+ 'mod_spox/Pipeline',
+ 'mod_spox/models/Models',
+ 'mod_spox/messages/Messages',
+ 'mod_spox/Plugin',
+ 'mod_spox/PluginHolder'].each{|f|require f}
 module ModSpox
 
     class PluginManager
@@ -17,14 +23,26 @@ module ModSpox
             @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(mesasge=nil)
-            unload_plugins
-            load_plugins
+        def reload_plugins(message=nil)
+            @plugin_lock.synchronize do
+                if(message.fresh && message.stale)
+                    do_unload(message.stale)
+                    FileUtils.remove_file(message.stale)
+                    FileUtils.copy(message.fresh, BotConfig[:userpluginpath])
+                    do_load(message.stale)
+                    Logger.log("Completed reload of plugin: #{message.stale}")
+                else
+                    unload_plugins
+                    load_plugins
+                end
+                @pipeline << Messages::Internal::SignaturesUpdate.new
+            end
         end
         
         # Destroys plugins
@@ -36,32 +54,34 @@ module ModSpox
         # Loads a plugin
         def load_plugin(message)
             begin
-                path = !message.name ? BotConfig[:userpluginpath] : "#{BotConfig[:userpluginpath]}/#{message.name}"
+                path = !message.name ? "#{BotConfig[:userpluginpath]}/#{message.path.gsub(/^.+\//, '')}" : "#{BotConfig[:userpluginpath]}/#{message.name}"
                 FileUtils.copy(message.path, path)
-                reload_plugins
+                do_load(path)
                 @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} Reason: #{boom}", 10)
                 @pipeline << Messages::Internal::PluginLoadResponse.new(message.requester, false)
             end
+            @pipeline << Messages::Internal::SignaturesUpdate.new
         end
         
         # message:: Messages::Internal::PluginUnloadRequest
         # Unloads a plugin
         def unload_plugin(message)
             begin
+                do_unload(message.path)
                 unless(message.name.nil?)
                     FileUtils.copy(message.path, "#{BotConfig[:userpluginpath]}/#{message.name}")
                 end
                 FileUtils.remove_file(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
+            @pipeline << Messages::Internal::SignaturesUpdate.new
         end
         
         # message:: Messages::Internal::PluginModuleRequest
@@ -86,39 +106,117 @@ module ModSpox
         # Loads and initializes plugins
         def load_plugins
             @pipeline << Messages::Internal::TimerClear.new
-            [BotConfig[:pluginpath], BotConfig[:userpluginpath]].each{|path|
-                Dir.new(path).each{|file|
+            Models::Signature.destroy_all
+            [BotConfig[:pluginpath], BotConfig[:userpluginpath]].each do |path|
+                Dir.new(path).each do |file|
                     if(file =~ /^[^\.].+\.rb$/)
                         begin
-                            @plugins_module.module_eval(IO.readlines("#{path}/#{file}").join("\n"))
+                            do_load("#{path}/#{file}")
                         rescue Object => boom
                             Logger.log("Failed to load file: #{path}/#{file}. Reason: #{boom}")
                         end
                     end
-                }
-            }
-            @plugins_module.constants.each{|const|
-                klass = @plugins_module.const_get(const)
-                if(klass < Plugin)
-                    begin
-                        @plugins[const.to_sym] = klass.new(@pipeline)
-                        Logger.log("Initialized new plugin: #{const}", 15)
-                    rescue Object => boom
-                        Logger.log("Failed to initialize plugin #{const}. Reason: #{boom}")
-                    end
                 end
-            }
+            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.each_pair do |sym, holder|
+                holder.plugin.destroy
+                @pipeline.unhook_plugin(holder.plugin)
+            end
+            Models::Signature.destroy_all
             @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))
+                        else
+                            @plugins[plugin.to_sym] = PluginHolder.new(klass.new(@pipeline))
+                        end
+                        Logger.log("Properly initialized new plugin: #{plugin}", 25)
+                    end
+                    Logger.log("All plugins found at: #{path} have been loaded")
+                rescue Object => boom
+                    Logger.log("Plugin loading failed: #{boom}\n#{boom.backtrace.join("\n")}", 25)
+                    Logger.log("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 
+                        @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).destroy
+                end
+                discover_consts(path).each do |const|
+                    Logger.log("Removing constant: #{const}")
+                    @plugins_module.send(:remove_const, const)
+                end
+                Logger.log("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
+        
+        class PluginMissing < Exceptions::BotException
+        end
+        
+        class PluginFileNotFound < Exceptions::BotException
+        end
     
     end
 

data/lib/mod_spox/Pool.rb

@@ -1,15 +1,20 @@
+['mod_spox/Logger',
+ 'mod_spox/Exceptions',
+ 'mod_spox/Monitors',
+ 'timeout'].each{|f|require f}
+ 
 module ModSpox
 
     # The Pool class is used to reduce thread creation. It provides
-    # an easy way to process many objects in an asynchronous manner.
+    # an easy way to process many actions in an asynchronous manner.
     class Pool
-
+    
         # Action thread is to perform
         attr_reader :proc
         # Storage space that the pool will be processing
         attr_reader :queue
         
-        # Create a new Pool
+        # Create a new pool
         def initialize
             @proc = Proc.new{ run_processor }
             @queue = PoolQueue.new
@@ -31,10 +36,12 @@ module ModSpox
             begin
                 processor
             rescue Object => boom
-                Logger.log("Pool encountered an error processing code block: #{boom}")
+                Logger.log("Pool encountered an error processing code block: #{boom}", 99)
             end
         end
 
+        # Action the pool is responsible for. This is the method
+        # the child class should override
         def processor
             raise Exceptions::NotImplemented.new('Processor method has not been implemented')
         end
@@ -43,21 +50,30 @@ module ModSpox
         @@pools = Array.new
         # Threads running in pool
         @@threads = Array.new
-        # Lock for thread safety
-        @@lock = Mutex.new
+        # Schedule lock for thread safety
+        @@schedule_lock = Mutex.new
+        # Thread creation lock
+        @@thread_lock = Mutex.new
         # Maximum number of seconds a thread may spend waiting for an action
         @@max_exec_time = 60
+        # Maximum number of threads to process Pool
+        @@max_threads = 10
+        # Maxium wait time (max time for threads to wait for new action to process)
+        @@max_wait_time = 20
+        # Monitor for threads to wait in
+        @@stop_point = Monitors::Timer.new
         # Informs threads to halt
         @@kill = false
         
         # Adds a new thread to the pool
-        def Pool.add_thread
-            @@threads << Thread.new do
-                until(Pool.max_queue_size < 1 || @@kill) do
+        def Pool.add_thread(force=false)
+            if(force || @@threads.size < @@max_threads)
+                thr = Thread.new do
                     Pool.schedule_thread
                 end
-                @@threads.delete(Thread.current)
+                @@threads << thr
             end
+            @@stop_point.wakeup
         end
         
         # Returns the largest queue size of all available pools
@@ -72,12 +88,15 @@ module ModSpox
         # Schedules a thread within the pool
         def Pool.schedule_thread
             run_pool = nil
-            @@lock.synchronize do
+            @@schedule_lock.synchronize do
                 @@pools.each do |pool|
                     run_pool = pool if (run_pool.nil? && pool.queue.size > 0) || (!run_pool.nil? && (run_pool.queue.size < pool.queue.size))
                 end
             end
-            unless(run_pool.nil?)
+            if(run_pool.nil?)
+                @@threads.delete(Thread.current)
+                return
+            else
                 begin
                     Timeout::timeout(@@max_exec_time) do
                         run_pool.proc.call
@@ -88,14 +107,23 @@ module ModSpox
                     Logger.log("Thread encountered error processing pool item: #{boom}")
                 end
             end
+            start = Time.now
+            @@stop_point.wait(@@max_wait_time) if Pool.max_queue_size < 1
+            if((Time.now - start).to_i < @@max_wait_time)
+                Pool.schedule_thread
+            else
+                @@threads.delete(Thread.current)
+                @@threads.each do |thread|
+                    @@threads.delete(thread) unless thread.alive?
+                end
+            end
         end
         
         # Forces sleeping threads to wake up
         def Pool.process
-            sleep(0.1)
-            Pool.add_thread if Pool.max_queue_size > 0
-            Logger.log("Current number of threads: #{@@threads.size}")
-            Logger.log("Total number of threads in use system-wide: #{Thread.list.size}")
+            @@thread_lock.synchronize do
+                Pool.add_thread if Pool.max_queue_size > 0
+            end
         end
         
         # Adds a Pool to the master Pool list        
@@ -106,8 +134,12 @@ module ModSpox
         # Removes a Pool from the master Pool list
         def Pool.remove_pool(pool)
             @@pools.delete(pool)
-            sleep(0.1)
-            @@threads.each{|t| t.kill} if @@pools.empty?
+            if(@@pools.empty?)
+                @@kill = true
+                @@stop_point.wakeup
+                sleep(0.1)
+                @@threads.each{|t| t.kill if t.alive?}
+            end
         end
         
         # Modified Queue to properly interact with Pool
@@ -119,17 +151,14 @@ module ModSpox
             end
             
             def <<(val)
-                @lock.synchronize do
-                    super
-                    Pool.process
-                end
+                push(val)
             end
             
             def push(val)
                 @lock.synchronize do
                     super
-                    Pool.process
                 end
+                Pool.process
             end
             
             def pop

data/lib/mod_spox/Socket.rb

@@ -1,3 +1,10 @@
+['mod_spox/Logger',
+ 'mod_spox/Pool',
+ 'mod_spox/Exceptions',
+ 'mod_spox/messages/Messages',
+ 'mod_spox/models/Models',
+ 'mod_spox/Pipeline'].each{|f|require f}
+
 module ModSpox
 
     class Socket < Pool
@@ -34,6 +41,7 @@ module ModSpox
             @check_burst = 0
             @pause = false
             @sendq = @queue
+            @lock = Mutex.new
             start_pool
         end
         
@@ -96,7 +104,7 @@ module ModSpox
         # Retrieves a string from the server
         def read
             message = @socket.gets
-            if(message.nil?) # || message =~ /^ERROR/)
+            if(message.nil? || @socket.closed?) # || message =~ /^ERROR/)
                 @pipeline << Messages::Internal::Disconnected.new
                 shutdown
                 server = Models::Server.find_or_create(:host => @server, :port => @port)
@@ -118,15 +126,18 @@ module ModSpox
         
         # Starts the thread for sending messages to the server
         def processor
-            write(@sendq.pop)
-            if((Time.now.to_i - @time_check) > @burst_in)
-                @time_check = nil
-                @check_burst = 0
-            elsif((Time.now.to_i - @time_check) >= @burst_in && @check_burst >= @burst)
-                sleep(@delay)
-                @time_check = nil
-                @check_burst = 0
-            end    
+            @lock.synchronize do
+                write(@sendq.pop)
+                if((Time.now.to_i - @time_check) > @burst_in)
+                    @time_check = nil
+                    @check_burst = 0
+                elsif((Time.now.to_i - @time_check) <= @burst_in && @check_burst >= @burst)
+                    Logger.log("Burst limit hit. Output paused for: #{@delay} seconds", 70)
+                    sleep(@delay)
+                    @time_check = nil
+                    @check_burst = 0
+                end
+            end
         end
         
         # Starts the thread for reading messages from the server