mod_spox 0.2.0 → 0.3.0

data/lib/mod_spox/Pipeline.rb

@@ -1,13 +1,13 @@
 ['mod_spox/models/Models.rb',
  'mod_spox/Logger',
- 'mod_spox/Pool',
  'mod_spox/Exceptions'].each{|f|require f}
 module ModSpox
 
     class Pipeline
 
         # Create a new Pipeline
-        def initialize
+        def initialize(pool)
+            @pool = pool
             @hooks = Hash.new
             @plugins = Hash.new
             @admin = Models::Group.filter(:name => 'admin').first
@@ -93,6 +93,9 @@ module ModSpox
         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]$/)
@@ -117,7 +120,7 @@ module ModSpox
             begin
                 Logger.info("Pipeline is processing a message: #{message}")
                 parse(message)
-                type = message.class.to_s.gsub(/^(ModSpox::Messages::|#<.+?>::)/, '').gsub(/::/, '_').to_sym
+                type = message.class.to_s.gsub(/^(ModSpox::Messages::|#<.+?>::)/, '').gsub('::', '_').to_sym
                 mod = type.to_s.gsub(/_.+$/, '').to_sym
                 Logger.info("Pipeline determines that #{message} is of type: #{type}")
                 [type, mod, :all].each do |type|
@@ -125,7 +128,18 @@ module ModSpox
                         @hooks[type].each_value do |objects|
                             begin
                                 objects.each do |v|
-                                    Pool << lambda{ v[:object].send(v[:method].to_s, message) }
+                                    @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")}")
@@ -145,7 +159,7 @@ module ModSpox
         def parse(message)
             return unless message.kind_of?(Messages::Incoming::Privmsg) || message.kind_of?(Messages::Incoming::Notice)
             trigger = nil
-            @triggers.each{|t| trigger = t if message.message =~ /^#{Regexp.escape(t)}/}
+            @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")
@@ -164,7 +178,7 @@ module ModSpox
                     esc_trig = trigger.nil? ? '' : Regexp.escape(trigger)
                     res = message.message.scan(/^#{esc_trig}#{sig.signature}$/)
                     if(res.size > 0)
-                        next unless message.source.auth_groups.include?(sig.group) || message.source.auth_groups.include?(@admin) || sig.group.nil?
+                        next unless message.source.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
@@ -174,7 +188,7 @@ module ModSpox
                         end
                         if(@plugins.has_key?(sig.plugin.to_sym))
                             begin
-                                Pool << lambda{ @plugins[sig.plugin.to_sym].send(sig.values[:method], message, params) }
+                                @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

data/lib/mod_spox/Plugin.rb

@@ -58,15 +58,39 @@ module ModSpox
             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)
-            sig = Signature.find_or_create(:signature => args[:sig], :plugin => name, :method => args[:method].to_s)
+            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.group_id = args[:group].pk if args.has_key?(:group)
             sig.requirement = args[:req] if args.has_key?(:req)
-            sig.params = args[:params] if args.has_key?(:params)
             sig.save
         end
+        
+        # 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/PluginManager.rb

@@ -30,18 +30,24 @@ module ModSpox
         # message:: Messages::Internal::PluginReload
         # Destroys and reinitializes 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.info("Completed reload of plugin: #{message.stale}")
-                else
-                    unload_plugins
-                    load_plugins
+            @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
-                @pipeline << Messages::Internal::SignaturesUpdate.new
+            rescue Object => boom
+                Logger.error("PluginManager caught error on plugin reload: #{boom}")
+            ensure
+                @pipeline << Messages::Internal::UnqueueSocket.new
             end
         end
 
@@ -53,6 +59,7 @@ module ModSpox
         # 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
@@ -66,13 +73,16 @@ module ModSpox
             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
-            @pipeline << Messages::Internal::SignaturesUpdate.new
         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))
@@ -86,8 +96,10 @@ module ModSpox
             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
-            @pipeline << Messages::Internal::SignaturesUpdate.new
         end
 
         # message:: Messages::Internal::PluginModuleRequest
@@ -116,7 +128,7 @@ module ModSpox
         # Loads and initializes plugins
         def load_plugins
             @pipeline << Messages::Internal::TimerClear.new
-            Models::Signature.destroy_all
+            Models::Signature.set(:enabled => false)
             [BotConfig[:pluginpath], BotConfig[:userpluginpath]].each do |path|
                 Dir.new(path).each do |file|
                     if(file =~ /^[^\.].+\.rb$/)
@@ -129,11 +141,11 @@ module ModSpox
                 end
             end
             @pipeline << Messages::Internal::SignaturesUpdate.new
+            @pipeline << Messages::Internal::PluginsReady.new
         end
 
         # Destroys plugins
         def unload_plugins
-            Models::Signature.destroy_all
             @plugins.each_pair do |sym, holder|
                 begin
                     holder.plugin.destroy unless holder.plugin.nil?
@@ -162,6 +174,7 @@ module ModSpox
                             @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

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

data/lib/mod_spox/Socket.rb

@@ -1,10 +1,10 @@
 ['iconv',
  'mod_spox/Logger',
- 'mod_spox/Pool',
  'mod_spox/Exceptions',
  'mod_spox/messages/Messages',
  'mod_spox/models/Models',
- 'mod_spox/Pipeline'].each{|f|require f}
+ 'mod_spox/Pipeline',
+ 'mod_spox/PriorityQueue'].each{|f|require f}
 
 module ModSpox
 
@@ -18,6 +18,7 @@ module ModSpox
         attr_reader :server
         attr_reader :port
         attr_reader :socket
+        attr_reader :connected_at
 
         # factory:: MessageFactory to parse messages
         # server:: Server to connect to
@@ -26,12 +27,13 @@ module ModSpox
         # 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)
+        def initialize(bot, server=nil, port=nil, delay=2, burst_in=2, burst=4)
+            @pool = bot.pool
             @factory = bot.factory
             @pipeline = bot.pipeline
             @dcc = bot.dcc_sockets
             @server = server
-            @port = port.to_i
+            @port = port
             @sent = 0
             @received = 0
             @delay = delay.to_f > 0 ? delay.to_f : 2.0
@@ -41,19 +43,35 @@ module ModSpox
             @time_check = nil
             @check_burst = 0
             @pause = false
-            @sendq = Queue.new
+            @sendq = PriorityQueue.new
             @lock = Mutex.new
             @ic = Iconv.new('UTF-8//IGNORE', 'UTF-8')
+            @connected_at = nil
+            @empty_lines = 0
+            @max_empty = 5
+            @servers = Array.new
+            @connect_locker = Mutex.new
         end
 
         # Connects to the IRC server
         def connect
-            Logger.info("Establishing connection to #{@server}:#{@port}")
-            @socket = TCPSocket.new(@server, @port)
-            server = Models::Server.find_or_create(:host => @server, :port => @port)
-            server.connected = true
-            server.save
-            Logger.info("Created new send queue: #{@sendq}")
+            return unless @connect_locker.try_lock
+            begin
+                populate_servers if @servers.empty?
+                s = @servers.pop
+                @server = s.host
+                @port = s.port.to_i
+                Logger.info("Establishing connection to #{@server}:#{@port}")
+                @socket = TCPSocket.new(@server, @port)
+                @socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true)
+                @empty_lines = 0
+                s.connected = true
+                s.save
+                @connected_at = Time.now
+                @pipeline << Messages::Internal::Connected.new(@server, @port)
+            ensure
+                @connect_locker.unlock
+            end
         end
 
         # new_delay:: Seconds to delay between bursts
@@ -87,65 +105,81 @@ module ModSpox
         # Sends a string to the IRC server
         def write(message)
             return if message.nil?
-            @socket.puts(message + "\n")
-            Logger.info("<< #{message}")
-            @last_send = Time.new
-            @sent += 1
-            @check_burst += 1
-            @time_check = Time.now.to_i if @time_check.nil?
+            begin
+                @socket.puts(message + "\n")
+                @socket.flush
+                Logger.info("<< #{message}")
+                @last_send = Time.new
+                @sent += 1
+                @check_burst += 1
+                @time_check = Time.now.to_i if @time_check.nil?
+            rescue Object => boom
+                Logger.warn("Failed to write message to server. #{boom}")
+                @pipeline << Messages::Internal::Disconnected.new
+                raise Exceptions::Disconnected.new
+            end
         end
-
-        # Retrieves a string from the server
-        def read
-            tainted_message = @socket.gets
-            if(tainted_message.nil? || @socket.closed?) # || message =~ /^ERROR/)
+        
+        # string:: string to be processed
+        # Process a string
+        def process(string)
+            string.strip!
+            Logger.info(">> #{string}")
+            if(string[0,5] == 'ERROR')
                 @pipeline << Messages::Internal::Disconnected.new
-                shutdown
-                server = Models::Server.find_or_create(:host => @server, :port => @port)
-                server.connected = false
-                server.save
-            elsif(tainted_message.length > 0)
-                message = @ic.iconv(tainted_message + ' ')[0..-2]
-                message.strip!
-                Logger.info(">> #{message}")
-                @received += 1
-                begin
-                    message.strip!
-                rescue Object => boom
-                    #do nothing#
-                ensure
-                    @factory << message
-                end
+                raise Exceptions::Disconnected.new
             end
+            @received += 1
+            @factory << string
         end
 
         # message:: String to be sent to server
         # Queues a message up to be sent to the IRC server
         def <<(message)
-            @sendq << message
-            Pool << lambda{ processor }
+            @sendq.direct_queue(message)
+            @pool.process{ processor }
+        end
+        
+        # target:: Target for outgoing message
+        # message:: Message to send
+        # This queues a message to be sent out of a prioritized
+        # queue. This allows for even message distribution rather
+        # than only on target at a time being flooded.
+        def prioritize_message(target, message)
+            @sendq.priority_queue(target, message)
+            @pool.process{ processor }
         end
 
         # Starts the thread for sending messages to the server
         def processor
-            @lock.synchronize do
-                write(@sendq.pop(true))
-                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.warn("Burst limit hit. Output paused for: #{@delay} seconds")
-                    sleep(@delay)
-                    @time_check = nil
-                    @check_burst = 0
+            return unless @lock.try_lock
+            did_write = false
+            begin
+                loop do
+                    write(@sendq.pop)
+                    did_write = true
+                    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.warn("Burst limit hit. Output paused for: #{@delay} seconds")
+                        sleep(@delay)
+                        @time_check = nil
+                        @check_burst = 0
+                    end
                 end
+            rescue Exceptions::EmptyQueue => boom
+                Logger.info('Socket reached an empty queue.')
+            ensure
+                @lock.unlock
+                @pool.process{ processor } if did_write
             end
         end
 
         # restart:: Reconnect after closing connection
         # Closes connection to IRC server
         def shutdown(restart=false)
-            @socket.close unless @socket.closed?
+            @socket.close unless @socket.nil? || @socket.closed?
             @kill = true
             server = Models::Server.find_or_create(:host => @server, :port => @port)
             server.connected = false
@@ -154,6 +188,14 @@ module ModSpox
             connect if restart
         end
 
+        private
+
+        def populate_servers
+            Models::Server.reverse_order(:priority).each{|s|
+                @servers << s
+            }
+        end
+
     end
 
 end