mod_spox 0.2.0 → 0.3.0

data/lib/mod_spox/Sockets.rb

@@ -6,6 +6,8 @@
  'mod_spox/Socket'
 ].each{|f| require f}
 
+require 'spockets'
+
 module ModSpox
 
     class Sockets
@@ -17,28 +19,45 @@ module ModSpox
             @irc_socket = nil
             @dcc_sockets = []
             @mapped_sockets = {}
-            @read_sockets = []
+            @spockets = Spockets::Spockets.new(:pool => bot.pool)
             @listening_dcc = []
             @dcc_ports = {:start => 49152, :end => 65535}
             @dcc_wait = 30
-            @read_thread = nil
             @pipeline = bot.pipeline
             @factory = bot.factory
             @pipeline.hook(self, :check_dcc, :Incoming_Privmsg)
             @pipeline.hook(self, :return_socket, :Internal_DCCRequest)
             @pipeline.hook(self, :dcc_listener, :Internal_DCCListener)
-            @kill = false
-            @ic = Iconv.new('UTF-8//IGNORE', 'UTF-8')
+            @pipeline.hook(self, :disconnect_irc, :Internal_Disconnected)
+            @pipeline.hook(self, :queue_messages, :Internal_QueueSocket)
+            @pipeline.hook(self, :unqueue_messages, :Internal_UnqueueSocket)
+            @queues = {:irc => Queue.new, :dcc => Queue.new}
+            @queue_messages = false
         end
 
         # server:: IRC server string
         # port:: IRC port
         # Connect to the given IRC server
-        def irc_connect(server, port)
-            @irc_socket = Socket.new(@bot, server, port)
-            @irc_socket.connect
-            @read_sockets << @irc_socket.socket
-            restart_reader
+        def irc_connect(server=nil, port=nil)
+            if(@irc_socket.nil?)
+                @irc_socket = Socket.new(@bot, server, port)
+                @irc_socket.connect
+                @spockets.add(@irc_socket.socket){|string| process_irc_string(string)}
+                @spockets.on_close(@irc_socket.socket){ irc_reconnect }
+            else
+                irc_reconnect
+            end
+        end
+        
+        def irc_reconnect
+            unless(@irc_socket.nil?)
+                disconnect_irc
+                @spockets.remove(@irc_socket.socket) if @spockets.include?(@irc_socket)
+                @irc_socket.shutdown(true)
+                @spockets.add(@irc_socket.socket){|string| process_irc_string(string)}
+            else
+                irc_connect
+            end
         end
 
         def <<(message)
@@ -46,11 +65,14 @@ module ModSpox
                 id = $1.to_i
                 message = $2 + "\r\n"
                 sock_info = @mapped_sockets[id]
-                socket = sock_info[:socket]
+                sock_info[:socket] << message
             else
-                socket = @irc_socket
+                @irc_socket << message
             end
-            socket << message
+        end
+        
+        def prioritize_message(target, message)
+            @irc_socket.prioritize_message(target, message)
         end
 
         # message:: ModSpox::Messages::Incoming::Privmsg
@@ -105,11 +127,9 @@ module ModSpox
                         cport, cip = Object::Socket.unpack_sockaddr_in(addrinfo)
                     end
                     Logger.info("New DCC socket created for #{message.nick.nick} has connected from: #{cip}:#{cport}")
-                    stop_reader
                     @dcc_sockets << client
                     @mapped_sockets[client.object_id] = {:socket => client, :nick => message.nick}
-                    @read_sockets << client
-                    start_reader
+                    @spockets.add(socket){|string| process_dcc_string(string, socket)}
                 rescue Timeout::Error => boom
                     Logger.warn("Timeout reached waiting for #{message.nick.nick} to connect to DCC socket. Closing.")
                     client.close
@@ -124,13 +144,26 @@ module ModSpox
 
         # Shuts down all active sockets
         def shutdown
-            stop_reader
+            @spockets.clear
             @irc_socket.shutdown
             @dcc_sockets.each do |sock|
                 close_dcc(sock)
             end
         end
 
+        def disconnect_irc(m=nil)
+            @spockets.remove(@irc_socket.socket) if @spockets.include?(@irc_socket.socket)
+        end
+        
+        def unqueue_messages(m)
+            @queue_messages = false
+            flush_queues
+        end
+        
+        def queue_messages(m)
+            @queue_messages = true
+        end
+
         private
 
         # ip:: IP address to connect to
@@ -140,11 +173,9 @@ module ModSpox
         def build_connection(ip, port, nick)
             begin
                 socket = TCPSocket.new(ip, port)
-                stop_reader
-                @read_sockets << socket
+                @spockets.add(socket){|string| process_dcc_string(string, socket)}
                 @mapped_sockets[socket.object_id] = {:socket => socket, :nick => nick}
                 @dcc_sockets << socket
-                start_reader
                 Logger.info("New DCC connection established to #{nick.nick} on #{ip}:#{port}")
             rescue Object => boom
                 Logger.warn("DCC connection to #{nick.nick} on #{ip}:#{port} failed. #{boom}")
@@ -152,58 +183,40 @@ module ModSpox
         end
 
         def close_dcc(sock)
-            @read_sockets.delete(sock)
+            @spockets.remove(sock)
             @dcc_sockets.delete(sock)
             @mapped_sockets.delete(sock.object_id)
         end
 
-        def stop_reader
-            Logger.info('Stopping reader thread for sockets')
-            if(!@thread_read.nil? && @thread_read.alive?)
-                @kill = true
-                @thread_read.join(0.2)
-                @thread_read.kill if @thread_read.alive?
-                @kill = false
+        def process_irc_string(string)
+            if(@queue_messages)
+                @queues[:irc] << string
+            else
+                @irc_socket.process(string)
             end
-            Logger.info('Reader thread for sockets has been stopped')
-        end
-
-        def restart_reader
-            stop_reader
-            start_reader
         end
-
-
-        def start_reader
-            Logger.info('Starting reader thread for sockets')
-            if(!@thread_read.nil? && @thread_read.alive?)
-                Logger.warn('ERROR: Cannot start reader. Already running.')
+        
+        def process_dcc_string(string, socket)
+            if(@queue_messages)
+                @queues[:dcc] = {:string => string, :socket => socket}
             else
-                @thread_read = Thread.new do
-                    until @kill do
-                        begin
-                            result = Kernel.select(@read_sockets, nil, nil, nil)
-                            for sock in result[0] do
-                                unless(sock == @irc_socket.socket)
-                                    tainted_string = sock.gets
-                                    string = @ic.iconv(tainted_string + ' ')[0..-2]
-                                    Logger.info("DCC >> #{string}", false)
-                                    if(sock.closed? || string.nil?)
-                                        sock.close
-                                        close_dcc(sock)
-                                    else
-                                        @pipeline << Messages::Incoming::Privmsg.new(string, @mapped_sockets[sock.object_id][:nick], "::#{sock.object_id}::", string)
-                                    end
-                                else
-                                    @irc_socket.read
-                                end
-                            end
-                        rescue Object => boom
-                            Logger.warn("Socket error detected: #{boom}\n#{boom.backtrace}", false)
-                        end
-                    end
+                Logger.info("DCC >> #{string}")
+                if(socket.closed? || string.nil?)
+                    socket.close
+                    close_dcc(socket)
+                else
+                    @pipeline << Messages::Incoming::Privmsg.new(string, @mapped_sockets[socket.object_id][:nick], "::#{sock.object_id}::", string)
                 end
-                Logger.info('Reader thread for sockets has been started')
+            end
+        end
+        
+        def flush_queues
+            until(@queues[:irc].empty?)
+                process_irc_string(@queues[:irc].pop)
+            end
+            until(@queues[:dcc].empty?)
+                con = @queues[:dcc].pop
+                process_dcc_string(con[:string], con[:socket])
             end
         end
 

data/lib/mod_spox/Timer.rb

@@ -1,23 +1,17 @@
 ['mod_spox/Logger',
- 'mod_spox/Pipeline',
- 'mod_spox/Pool',
- 'mod_spox/Action',
- 'mod_spox/Exceptions'].each{|f|require f}
+ 'mod_spox/Pipeline'].each{|f|require f}
 
 module ModSpox
 
     class Timer
 
-        # pipeline:: message pipeline
-        # Create a new Timer
-        def initialize(pipeline)
+        # timer:: ActionTimer to use
+        # pipeline:: Message pipeline
+        # Creates a timer handler for interactions
+        # with the ActionTimer
+        def initialize(timer, pipeline)
             @pipeline = pipeline
-            @timers = Array.new
-            @timer_thread = nil
-            @stop_timer = false
-            @awake_lock = Mutex.new
-            @add_lock = Mutex.new
-            @new_actions = Queue.new
+            @timer = timer
             {:Internal_TimerAdd => :add_message,
              :Internal_TimerRemove => :remove_message,
              :Internal_TimerClear => :clear}.each_pair do |type,method|
@@ -25,153 +19,39 @@ module ModSpox
             end
         end
 
-        # Wakes the timer up early
-        def wakeup
-            @awake_lock.synchronize do
-                if(@timer_thread.status == 'sleep')
-                    Logger.info('Timer has been explicitly told to wakeup')
-                    @timer_thread.wakeup
-                end
-            end
-        end
-
         # message:: TimerAdd message
         # Add a recurring code block
         def add_message(message)
             Logger.info("New block is being added to the timer")
-            action = nil
-            @new_actions << {:period => message.period, :once => message.once, :data => message.data,
-                             :block => message.block, :requester => message.requester, :m_id => message.id}
-            wakeup
+            begin
+                action = @timer.add(message.period, message.once, message.data, message.requester, &message.block)
+                @pipeline << Messages::Internal::TimerResponse.new(message.requester, action, true, message.id)
+            rescue Object => boom
+                Logger.error("Failed to add new block to timer: #{boom}")
+                @pipeline << Messages::Internal::TimerResponse.new(message.requester, nil, false, message.id)
+            end
         end
 
         # message:: TimerRemove message
         # Remove an action from the timer
         def remove_message(message)
-            remove(message.action)
+            @timer.remove(message.action)
             Logger.info("Action has been removed from the Timer")
             @pipeline << Messages::Internal::TimerResponse.new(nil, message.action, false, message.id)
         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
-            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 @timer_thread.nil?
-            @timer_thread = Thread.new do
-            begin
-                until @stop_timer do
-                    to_sleep = get_min_sleep
-                    Logger.info("Timer is set to sleep for #{to_sleep.nil? ? 'forever' : "#{to_sleep} seconds"}")
-                    if((to_sleep.nil? || to_sleep > 0) && @new_actions.empty?)
-                        actual_sleep = to_sleep.nil? ? sleep : sleep(to_sleep)
-                    else
-                        actual_sleep = 0
-                    end
-                    Logger.info("Timer was set to sleep for #{to_sleep.nil? ? 'forever' : "#{to_sleep} seconds"}. Actual sleep: #{actual_sleep} seconds")
-                    tick(actual_sleep)
-                    add_waiting_actions
-                end
-            rescue Object => boom
-                Logger.warn("Timer error encountered: #{boom}")
-            end
-            Logger.warn("Timer has completed running.")
-            end
-        end
-
-        # Stops the timer
-        def stop
-            raise Exceptions::NotRunning.new('Timer is not running') if @timer_thread.nil?
-            @stop_timer = true
-            wakeup
-            @timer_thread.join
-        end
-
         # Clears all actions in the timer's queue
         def clear(message=nil)
             if(message.nil? || message.plugin.nil?)
-                @timers.clear
-                @new_actions.clear
-                wakeup
+                @timer.clear
             else
-                @timers.each{ |action| @timers.delete(action) if action.owner == message.plugin}
-                wakeup
-            end
-        end
-
-        private
-
-        def get_min_sleep
-            min = @timers.map{|t| t.remaining}.sort[0]
-            unless(min.nil? || min > 0)
-                @timers.each{|t| @timers.delete(t) if t.remaining == 0} # kill stuck actions
-                min = get_min_sleep
-            end
-            Logger.info("Total number of actions in timer: #{@timers.size}")
-            Logger.info("Actions belong to: #{@timers.map{|a| a.owner}.join(', ')}")
-            return min
-        end
-
-        def add_waiting_actions
-            until(@new_actions.empty?) do
-                a = @new_actions.pop
-                action = add(a[:period], a[:once], a[:data], &a[:block])
-                action.owner = a[:requester]
-                begin
-                    @pipeline << Messages::Internal::TimerResponse.new(a[:requester], action, true, a[:m_id])
-                    Logger.info("New block was successfully added to the timer")
-                rescue Object => boom
-                    Logger.warn("Failed to add block to timer: #{boom}")
-                    @pipeline << Messages::Internal::TimerResponse.new(a[:requester], action, false, a[:m_id])
-                end
+                @timer.clear(message.plugin)
             end
         end
-
-        # 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?)
-                    remove(action) if action.is_complete?
-                    block = action.schedule
-                    Pool << lambda{processor(block)}
-                end
-            end
-        end
-
-        # Process the actions
-        def processor(action)
-            begin
-                action.run
-            rescue Object => boom
-                Logger.warn("Timer block generated an exception: #{boom}\n#{boom.backtrace.join("\n")}")
-            end
+        
+        # stop the timer
+        def stop
+            @timer.stop
         end
 
     end

data/lib/mod_spox/Version.rb

@@ -0,0 +1,14 @@
+module ModSpox
+    @botversion='0.3.0'
+    @botcodename='potato flamer'
+    @verbosity = 0
+    @mod_spox_path = nil
+    @daemon_bot = false
+    @logto = nil
+    @loglevel = :fatal
+    @jdbc = false
+    class << self
+        attr_reader :botversion, :botcodename
+        attr_accessor :verbosity, :mod_spox_path, :daemon_bot, :logto, :loglevel, :jdbc
+    end
+end

data/lib/mod_spox/handlers/BadNick.rb

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

data/lib/mod_spox/handlers/Bounce.rb

@@ -7,11 +7,11 @@ module ModSpox
             end
             
             def process(string)
-                if(string =~ /:Try server (\S+), port (.+)$/)
-                    return Messages::Incoming::Bounce.new(string, $1, $2)
-                else
-                    return nil
-                end
+                orig = string.dup
+                2.times{string.slice!(0..string.index(' '))}
+                server = string.slice!(0..string.index(',')-1)
+                string.slice!(0..string.index(' ',4))
+                return Messages::Incoming::Bounce.new(orig, server, string)
             end
         end
     end