mod_spox 0.1.0.1 → 0.2.0

data/lib/mod_spox/Socket.rb

@@ -1,4 +1,5 @@
-['mod_spox/Logger',
+['iconv',
+ 'mod_spox/Logger',
  'mod_spox/Pool',
  'mod_spox/Exceptions',
  'mod_spox/messages/Messages',
@@ -7,8 +8,8 @@
 
 module ModSpox
 
-    class Socket < Pool
-    
+    class Socket
+
         attr_reader :sent
         attr_reader :received
         attr_reader :burst
@@ -16,7 +17,8 @@ module ModSpox
         attr_reader :delay
         attr_reader :server
         attr_reader :port
-    
+        attr_reader :socket
+
         # factory:: MessageFactory to parse messages
         # server:: Server to connect to
         # port:: Port number to connect to
@@ -25,9 +27,9 @@ module ModSpox
         # 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)
-            super()
             @factory = bot.factory
             @pipeline = bot.pipeline
+            @dcc = bot.dcc_sockets
             @server = server
             @port = port.to_i
             @sent = 0
@@ -36,120 +38,110 @@ module ModSpox
             @burst = burst.to_i > 0 ? burst.to_i : 4
             @burst_in = 2
             @kill = false
-            @reader_thread = nil
             @time_check = nil
             @check_burst = 0
             @pause = false
-            @sendq = @queue
+            @sendq = Queue.new
             @lock = Mutex.new
-            start_pool
+            @ic = Iconv.new('UTF-8//IGNORE', 'UTF-8')
         end
-        
+
         # Connects to the IRC server
         def connect
-            Logger.log("Establishing connection to #{@server}:#{@port}", 10)
+            Logger.info("Establishing connection to #{@server}:#{@port}")
             @socket = TCPSocket.new(@server, @port)
-            @socket.sync = true
             server = Models::Server.find_or_create(:host => @server, :port => @port)
             server.connected = true
             server.save
-            Logger.log("Created new send queue: #{@sendq}", 10)
-            reader
+            Logger.info("Created new send queue: #{@sendq}")
         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_burst.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?
-            @socket.puts(message + "\n") #send(message + "\n", 0)
-            Logger.log("<< #{message}", 5)
+            @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?
         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? || @socket.closed?) # || message =~ /^ERROR/)
+            tainted_message = @socket.gets
+            if(tainted_message.nil? || @socket.closed?) # || message =~ /^ERROR/)
                 @pipeline << Messages::Internal::Disconnected.new
                 shutdown
                 server = Models::Server.find_or_create(:host => @server, :port => @port)
                 server.connected = false
                 server.save
-                return
+            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
             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)
             @sendq << message
+            Pool << lambda{ processor }
         end
-        
+
         # Starts the thread for sending messages to the server
         def processor
             @lock.synchronize do
-                write(@sendq.pop)
+                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.log("Burst limit hit. Output paused for: #{@delay} seconds", 70)
+                    Logger.warn("Burst limit hit. Output paused for: #{@delay} seconds")
                     sleep(@delay)
                     @time_check = nil
                     @check_burst = 0
                 end
             end
         end
-        
-        # Starts the thread for reading messages from the server
-        def reader
-            @reader_thread = Thread.new do
-                until @kill do
-                    Kernel.select([@socket], nil, nil, nil)
-                    @factory << read
-                end
-            end
-        end
-        
+
         # restart:: Reconnect after closing connection
         # Closes connection to IRC server
         def shutdown(restart=false)
@@ -158,11 +150,10 @@ module ModSpox
             server = Models::Server.find_or_create(:host => @server, :port => @port)
             server.connected = false
             server.save
-            sleep(0.1)            
-            @reader_thread.kill if @reader_thread.alive?
+            sleep(0.1)
             connect if restart
         end
-        
+
     end
 
 end

data/lib/mod_spox/Sockets.rb

@@ -0,0 +1,211 @@
+['ipaddr',
+ 'iconv',
+ 'mod_spox/Bot',
+ 'mod_spox/Pipeline',
+ 'mod_spox/MessageFactory',
+ 'mod_spox/Socket'
+].each{|f| require f}
+
+module ModSpox
+
+    class Sockets
+
+        attr_reader :irc_socket
+
+        def initialize(bot)
+            @bot = bot
+            @irc_socket = nil
+            @dcc_sockets = []
+            @mapped_sockets = {}
+            @read_sockets = []
+            @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')
+        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
+        end
+
+        def <<(message)
+            if(message =~ /::(\S+)::\s:(.+)$/)
+                id = $1.to_i
+                message = $2 + "\r\n"
+                sock_info = @mapped_sockets[id]
+                socket = sock_info[:socket]
+            else
+                socket = @irc_socket
+            end
+            socket << message
+        end
+
+        # message:: ModSpox::Messages::Incoming::Privmsg
+        # Checks if incoming message is a request to
+        # start a DCC chat session and builds the connection
+        def check_dcc(message)
+            if(message.is_ctcp? && message.ctcp_type == 'DCC')
+                if(message.message =~ /^CHAT chat (\S+) (\S+)/)
+                    if(message.source.in_group?('dcc') || message.source.in_group?('admin'))
+                        ip = IPAddr.new($1.to_i, Object::Socket::AF_INET).to_s
+                        port = $2.to_i
+                        build_connection(ip, port, message.source)
+                    else
+                        Logger.warn("Error: #{message.source.nick} is attempting to establish DCC connection without permission.")
+                    end
+                end
+            end
+        end
+
+        # message:: ModSpox::Messages::Internal::DCCRequest
+        # Returns the DCC Socket requested in a ModSpox::Messages::Internal::DCCSocket
+        # message.
+        def return_socket(message)
+            socket = nick = nil
+            if(@mapped_socks.has_key?(message.socket_id))
+                socket = @mapped_socks[message.socket_id][:socket]
+                nick = @mapped_socks[message.socket_id][:nick]
+            end
+            @pipeline << Messages::Internal::DCCSocket.new(message.socket_id, nick, socket)
+        end
+
+        # message:: ModSpox::Messages::Internal::DCCListener
+        # Sets up a new socket for a user to connect to. Helpful
+        # if the user wants a DCC chat session but is firewalled
+        def dcc_listener(message)
+            Thread.new do
+                me = Models::Nick.filter(:botnick => true).first
+                return if me.nil?
+                port = rand(@dcc_ports[:end] - @dcc_ports[:start]) + @dcc_ports[:start]
+                socket = Object::Socket.new(Object::Socket::AF_INET, Object::Socket::SOCK_STREAM, 0)
+                addr = Object::Socket.pack_sockaddr_in(port, me.address)
+                socket.bind(addr)
+                client = nil
+                addrinfo = nil
+                cport = nil
+                cip = nil
+                begin
+                    Timeout::timeout(@dcc_wait) do
+                        @pipeline << Messages::Outgoing::Privmsg.new(message.nick, "CHAT chat #{IPAddr.new(me.address).to_i} #{port}", false, true, 'DCC')
+                        socket.listen(5)
+                        client, addrinfo = socket.accept
+                        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
+                rescue Timeout::Error => boom
+                    Logger.warn("Timeout reached waiting for #{message.nick.nick} to connect to DCC socket. Closing.")
+                    client.close
+                rescue Object => boom
+                    Logger.warn("Unknown error encountered while building DCC listener for: #{message.nick.nick}. Error: #{boom}")
+                    client.close
+                ensure
+                    socket.close
+                end
+            end
+        end
+
+        # Shuts down all active sockets
+        def shutdown
+            stop_reader
+            @irc_socket.shutdown
+            @dcc_sockets.each do |sock|
+                close_dcc(sock)
+            end
+        end
+
+        private
+
+        # ip:: IP address to connect to
+        # port:: Port to connect to
+        # nick:: Nick this connection is associated with
+        # Builds a DCC connection to given location
+        def build_connection(ip, port, nick)
+            begin
+                socket = TCPSocket.new(ip, port)
+                stop_reader
+                @read_sockets << 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}")
+            end
+        end
+
+        def close_dcc(sock)
+            @read_sockets.delete(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
+            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.')
+            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
+                end
+                Logger.info('Reader thread for sockets has been started')
+            end
+        end
+
+    end
+end

data/lib/mod_spox/Timer.rb

@@ -2,66 +2,57 @@
  'mod_spox/Pipeline',
  'mod_spox/Pool',
  'mod_spox/Action',
- 'mod_spox/Exceptions',
- 'mod_spox/Monitors'].each{|f|require f}
+ 'mod_spox/Exceptions'].each{|f|require f}
 
 module ModSpox
 
-    class Timer < Pool
-    
+    class Timer
+
         # pipeline:: message pipeline
         # Create a new Timer
         def initialize(pipeline)
-            super()
             @pipeline = pipeline
             @timers = Array.new
-            Logger.log("Created queue: #{@queue} in timer", 10)
-            @monitor = Monitors::Timer.new
-            @thread = nil
+            @timer_thread = nil
             @stop_timer = false
-            @owners = {}
-            @owners_lock = Mutex.new
+            @awake_lock = Mutex.new
+            @add_lock = Mutex.new
+            @new_actions = Queue.new
             {:Internal_TimerAdd => :add_message,
              :Internal_TimerRemove => :remove_message,
              :Internal_TimerClear => :clear}.each_pair do |type,method|
                 @pipeline.hook(self, method, type)
             end
-            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?
+            @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.log("New block is being added to the timer", 15)
+            Logger.info("New block is being added to the timer")
             action = nil
-            @owners_lock.synchronize do
-                action = add(message.period, message.once, message.data, &message.block)
-                @owners[message.requester.name.to_sym] = [] unless @owners.has_key?(message.requester.name.to_sym)
-                @owners[message.requester.name.to_sym] << action
-            end
-            begin
-                @pipeline << Messages::Internal::TimerResponse.new(message.requester, action, true, message.id)
-                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, message.id)
-            end
+            @new_actions << {:period => message.period, :once => message.once, :data => message.data,
+                             :block => message.block, :requester => message.requester, :m_id => message.id}
+            wakeup
         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)
+            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
@@ -70,18 +61,17 @@ module ModSpox
         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        
+        # 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)
@@ -89,74 +79,101 @@ module ModSpox
             @timers.delete(action)
             wakeup
         end
-        
+
         # Starts the timer
         def start
-            raise Exceptions::AlreadyRunning.new('Timer is already running') unless @thread.nil?
-            @thread = Thread.new{
+            raise Exceptions::AlreadyRunning.new('Timer is already running') unless @timer_thread.nil?
+            @timer_thread = Thread.new do
+            begin
                 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
+                    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.log("Timer is set to sleep for #{to_sleep.nil? ? 'forever' : "#{to_sleep} seconds"}", 15)
-                    actual_sleep = @monitor.wait(to_sleep)
+                    Logger.info("Timer was set to sleep for #{to_sleep.nil? ? 'forever' : "#{to_sleep} seconds"}. Actual sleep: #{actual_sleep} seconds")
                     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)
+                    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 @thread.nil?
+            raise Exceptions::NotRunning.new('Timer is not running') if @timer_thread.nil?
             @stop_timer = true
             wakeup
-            @thread.join
+            @timer_thread.join
         end
-        
+
         # Clears all actions in the timer's queue
         def clear(message=nil)
             if(message.nil? || message.plugin.nil?)
-                @queue.clear
                 @timers.clear
-                @owners.clear
+                @new_actions.clear
+                wakeup
             else
-                @owners_lock.synchronize do
-                    if(@owners.has_key?(message.plugin))
-                        @owners[message.plugin].each do |action|
-                            remove(action)
-                        end
-                    end
-                end
+                @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
+            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?)
-                    @queue << action.schedule
+                    remove(action) if action.is_complete?
+                    block = action.schedule
+                    Pool << lambda{processor(block)}
                 end
             end
         end
-        
+
         # Process the actions
-        def processor
-            action = @queue.pop
+        def processor(action)
             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)
+                Logger.warn("Timer block generated an exception: #{boom}\n#{boom.backtrace.join("\n")}")
             end
         end
-    
+
     end
-    
+
 end

data/lib/mod_spox/handlers/BadNick.rb

@@ -9,7 +9,7 @@ module ModSpox
                 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')
+                    Logger.warn('Failed to process RPL_ERRORONEOUSNICK message')
                     return nil
                 end
             end

data/lib/mod_spox/handlers/Created.rb

@@ -9,7 +9,7 @@ module ModSpox
                 if(string =~ /#{RPL_CREATED.to_s}.+?:created\s(.+)$/)
                     return Messages::Incoming::Created.new(string, $1)
                 else
-                    Logger.log('Failed to parse RPL_CREATED message')
+                    Logger.warn('Failed to parse RPL_CREATED message')
                     return nil
                 end
             end