mod_spox 0.1.0.1 → 0.2.0

data/lib/mod_spox/PluginManager.rb

@@ -8,10 +8,10 @@
 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)
@@ -26,7 +26,7 @@ module ModSpox
             @plugin_lock = Mutex.new
             load_plugins
         end
-        
+
         # message:: Messages::Internal::PluginReload
         # Destroys and reinitializes plugins
         def reload_plugins(message=nil)
@@ -36,7 +36,7 @@ module ModSpox
                     FileUtils.remove_file(message.stale)
                     FileUtils.copy(message.fresh, BotConfig[:userpluginpath])
                     do_load(message.stale)
-                    Logger.log("Completed reload of plugin: #{message.stale}")
+                    Logger.info("Completed reload of plugin: #{message.stale}")
                 else
                     unload_plugins
                     load_plugins
@@ -44,12 +44,12 @@ module ModSpox
                 @pipeline << Messages::Internal::SignaturesUpdate.new
             end
         end
-        
+
         # Destroys plugins
         def destroy_plugins
             unload_plugins
         end
-        
+
         # message:: Messages::Internal::PluginLoadRequest
         # Loads a plugin
         def load_plugin(message)
@@ -62,14 +62,14 @@ module ModSpox
                 end
                 do_load(path)
                 @pipeline << Messages::Internal::PluginLoadResponse.new(message.requester, true)
-                Logger.log("Loaded new plugin: #{message.path}", 10)
+                Logger.info("Loaded new plugin: #{message.path}")
             rescue Object => boom
-                Logger.log("Failed to load plugin: #{message.path} Reason: #{boom}", 10)
+                Logger.warn("Failed to load plugin: #{message.path} Reason: #{boom}")
                 @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)
@@ -82,20 +82,20 @@ module ModSpox
                 end
                 File.delete(message.path)
                 @pipeline << Messages::Internal::PluginUnloadResponse.new(message.requester, true)
-                Logger.log("Unloaded plugin: #{message.path}", 10)
+                Logger.info("Unloaded plugin: #{message.path}")
             rescue Object => boom
-                Logger.log("Failed to unload plugin: #{message.path} Reason: #{boom}", 10)
+                Logger.warn("Failed to unload plugin: #{message.path} Reason: #{boom}")
                 @pipeline << Messages::Internal::PluginUnloadResponse.new(message.requester, false)
             end
             @pipeline << Messages::Internal::SignaturesUpdate.new
         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)
@@ -106,9 +106,13 @@ module ModSpox
             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
@@ -119,25 +123,29 @@ module ModSpox
                         begin
                             do_load("#{path}/#{file}")
                         rescue Object => boom
-                            Logger.log("Failed to load file: #{path}/#{file}. Reason: #{boom}")
+                            Logger.warn("Failed to load file: #{path}/#{file}. Reason: #{boom}")
                         end
                     end
                 end
             end
             @pipeline << Messages::Internal::SignaturesUpdate.new
         end
-        
+
         # Destroys plugins
         def unload_plugins
+            Models::Signature.destroy_all
             @plugins.each_pair do |sym, holder|
-                holder.plugin.destroy unless holder.plugin.nil?
-                @pipeline.unhook_plugin(holder.plugin)
+                begin
+                    holder.plugin.destroy unless holder.plugin.nil?
+                    @pipeline.unhook_plugin(holder.plugin)
+                rescue Object => boom
+                    Logger.warn("Plugin destruction error: #{boom}")
+                end
             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)
@@ -149,46 +157,46 @@ module ModSpox
                     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))
+                            @plugins[plugin.to_sym].set_plugin(klass.new({:pipeline => @pipeline, :plugin_module => @plugins_module}))
                         else
-                            @plugins[plugin.to_sym] = PluginHolder.new(klass.new(@pipeline))
+                            @plugins[plugin.to_sym] = PluginHolder.new(klass.new({:pipeline => @pipeline, :plugin_module => @plugins_module}))
                         end
-                        Logger.log("Properly initialized new plugin: #{plugin}", 25)
+                        Logger.info("Properly initialized new plugin: #{plugin}")
                     end
-                    Logger.log("All plugins found at: #{path} have been loaded")
+                    Logger.info("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")
+                    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 
+                        @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).destroy
+                    Models::Signature.filter(:plugin => plugin.to_s).destroy
                 end
                 discover_consts(path).each do |const|
-                    Logger.log("Removing constant: #{const}")
+                    Logger.info("Removing constant: #{const}")
                     @plugins_module.send(:remove_const, const)
                 end
-                Logger.log("Removed all constants found in file: #{path}")
+                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)
@@ -203,9 +211,9 @@ module ModSpox
                 return klasses
             rescue Object => boom
                 return nil
-            end     
+            end
         end
-        
+
         # path:: path to plugin
         # Find all constant names in given path
         def discover_consts(path)
@@ -217,13 +225,13 @@ module ModSpox
                 return nil
             end
         end
-        
+
         class PluginMissing < Exceptions::BotException
         end
-        
+
         class PluginFileNotFound < Exceptions::BotException
         end
-    
+
     end
 
 end

data/lib/mod_spox/Pool.rb

@@ -1,178 +1,164 @@
 ['mod_spox/Logger',
  'mod_spox/Exceptions',
- 'mod_spox/Monitors',
- 'timeout'].each{|f|require f}
- 
+ 'timeout',
+ 'singleton'].each{|f|require f}
+
 module ModSpox
 
+    class PoolThread
+        def initialize(pool, timeout)
+            @pool = pool
+            @timeout = timeout
+            @kill = false
+            @thread = Thread.new do
+                until @kill do
+                    begin
+                        action = nil
+                        if(Pool.workers > Pool.workers_min)
+                            Timeout::timeout(60) do
+                                action = @pool.queue.pop
+                            end
+                        else
+                            action = @pool.queue.pop
+                        end
+                        run(action) unless action.nil?
+                    rescue Timeout::Error => boom
+                        @kill = true
+                    rescue Object => boom
+                        Logger.warn("Pool thread error: #{boom}")
+                    end
+                end
+                @pool.remove(self)
+            end
+        end
+        
+        private
+        
+        def run(action)
+            begin
+                if(@timeout > 0)
+                    Timeout::timeout(@timeout) do
+                        action.call
+                    end
+                else
+                    action.call
+                end
+            rescue Timeout::Error => boom
+                Logger.warn("Pool worker timed out during execution of action (#{@timeout} sec limit): #{action}")
+            rescue Object => boom
+                Logger.warn("Pool worker caught an unknown exception: #{boom}")
+            end
+        end
+    end
+
     # The Pool class is used to reduce thread creation. It provides
     # 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
+        include Singleton
+
+        # Add an action to the pool to be processed
+        def Pool.<<(action)
+            Pool.instance.add(action)
+        end
         
-        # Create a new pool
-        def initialize
-            @proc = Proc.new{ run_processor }
-            @queue = PoolQueue.new
+        # Alias of Pool.<<(action)
+        def Pool.queue(action)
+            Pool << action
         end
         
-        # Destroys this pool
-        def destroy
-            Pool.remove_pool(self)
+        def Pool.workers
+            Pool.instance.threads.size
         end
         
-        # Starts the pool
-        def start_pool
-            Pool.add_pool(self)
+        def Pool.workers_min
+            return Pool.instance.min
         end
         
-        private 
+        def Pool.workers_max
+            return Pool.instance.max
+        end
         
-        def run_processor
-            begin
-                processor
-            rescue Object => boom
-                Logger.log("Pool encountered an error processing code block: #{boom}", 99)
-            end
+        def remove(pt)
+            @threads.delete(pt)
+            Logger.info("Pool thread has been removed: #{pt}")
+        end
+        
+        def add(action)
+            @queue << action
+            create_pool_thread if @queue.size > @min
+        end
+        
+        # Return maximum number of seconds actions are allowed to process
+        def Pool.worker_timeout
+            Pool.instance.timeout
         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
-        
-        # Running pools
-        @@pools = Array.new
-        # Threads running in pool
-        @@threads = Array.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(force=false)
-            if(force || @@threads.size < @@max_threads)
-                thr = Thread.new do
-                    Pool.schedule_thread
-                end
-                @@threads << thr
-            end
-            @@stop_point.wakeup
+        # time:: number of seconds actions are allowed
+        # Set number of seconds actions are allowed to work
+        def Pool.worker_timeout=(time)
+            Pool.instance.timeout = time
+        end
+
+        # Set maximum number of workers to process tasks
+        def Pool.workers_max=(max)
+            Pool.instance.workers_max = max
         end
         
-        # Returns the largest queue size of all available pools
-        def Pool.max_queue_size
-            size = 0
-            @@pools.each do |pool|
-                size = pool.queue.size if pool.queue.size > size
-            end
-            return size
+        # Not currently implemented
+        def Pool.workers_min=(min)
+            Pool.instance.workers_min = min
         end
         
-        # Schedules a thread within the pool
-        def Pool.schedule_thread
-            run_pool = nil
-            @@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
-            if(run_pool.nil?)
-                @@threads.delete(Thread.current)
-                return
-            else
-                begin
-                    Timeout::timeout(@@max_exec_time) do
-                        run_pool.proc.call
-                    end
-                rescue Timeout::Error => boom
-                    Logger.log("Thread reached maximum execution time (#{@max_exec_time}) processing pool item")
-                rescue Object => boom
-                    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
+        attr_reader :threads
+        attr_reader :queue
+        attr_reader :min
+        attr_reader :max
+        attr_reader :timeout
+    
+        def initialize
+            @queue = Queue.new
+            @threads = []
+            @lock = Mutex.new
+            @timeout = get_value('pool_timeout', 0).to_i
+            @max = Database.type != :pgsql ? 1 : get_value('pool_workers_max', 7).to_i
+            @min = Database.type != :pgsql ? 1 : get_value('pool_workers_min', 5).to_i
+            @min.times{create_pool_thread}
         end
         
-        # Forces sleeping threads to wake up
-        def Pool.process
-            @@thread_lock.synchronize do
-                Pool.add_thread if Pool.max_queue_size > 0
-            end
+        def create_pool_thread(force=false)
+            return nil unless @threads.size < @max || force
+            pt = PoolThread.new(self, @timeout)
+            @threads << pt
+            return pt
         end
         
-        # Adds a Pool to the master Pool list        
-        def Pool.add_pool(pool)
-            @@pools << pool
+        def get_value(n, default)
+            m = Models::Config.filter(:name => n).first
+            return m.nil? ? default : m.value
         end
         
-        # Removes a Pool from the master Pool list
-        def Pool.remove_pool(pool)
-            @@pools.delete(pool)
-            if(@@pools.empty?)
-                @@kill = true
-                @@stop_point.wakeup
-                sleep(0.1)
-                @@threads.each{|t| t.kill if t.alive?}
-            end
+        def set_value(n, v)
+            m = Models::Config.find_or_create(:name => n)
+            m.value = v
+            m.save
         end
         
-        # Modified Queue to properly interact with Pool
-        class PoolQueue < Queue
+        def timeout=(v)
+            set_value('pool_timeout', v.to_i)
+            @timeout = v.to_i
+        end
         
-            def initialize
-                super
-                @lock = Mutex.new
-            end
-            
-            def <<(val)
-                push(val)
-            end
-            
-            def push(val)
-                @lock.synchronize do
-                    super
-                end
-                Pool.process
-            end
-            
-            def pop
-                @lock.synchronize do
-                    if(size > 0)
-                        super
-                    else
-                        raise Exceptions::BotException.new("Queue is currently empty")
-                    end
-                end
-            end
-                
+        def workers_max=(v)
+            set_value('pool_workers_max', v.to_i)
+            @max = v.to_i
         end
-    
+        
+        def workers_min=(v)
+            set_value('pool_workers_min', v.to_i)
+            @min = v.to_i
+        end
+
     end
 
 end