spox-mod_spox 0.3.1

data/lib/mod_spox/Socket.rb

@@ -0,0 +1,201 @@
+['iconv',
+ 'mod_spox/Logger',
+ 'mod_spox/Exceptions',
+ 'mod_spox/messages/internal/Connected',
+ 'mod_spox/messages/internal/Disconnected',
+ 'mod_spox/models/Models',
+ 'mod_spox/Pipeline',
+ 'mod_spox/PriorityQueue'].each{|f|require f}
+ 
+module ModSpox
+
+    class Socket
+
+        attr_reader :sent
+        attr_reader :received
+        attr_reader :burst
+        attr_reader :burst_in
+        attr_reader :delay
+        attr_reader :server
+        attr_reader :port
+        attr_reader :socket
+        attr_reader :connected_at
+
+        # factory:: MessageFactory to parse messages
+        # server:: Server to connect to
+        # port:: Port number to connect to
+        # delay:: Number of seconds to delay between bursts
+        # 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=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
+            @sent = 0
+            @received = 0
+            @delay = delay.to_f > 0 ? delay.to_f : 2.0
+            @burst = burst.to_i > 0 ? burst.to_i : 4
+            @burst_in = 2
+            @kill = false
+            @time_check = nil
+            @check_burst = 0
+            @pause = false
+            @sendq = PriorityQueue.new
+            @lock = Mutex.new
+            @connected_at = nil
+            @empty_lines = 0
+            @max_empty = 5
+            @servers = Array.new
+            @connect_locker = Mutex.new
+        end
+
+        # Connects to the IRC server
+        def connect
+            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
+        # 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?
+            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
+        
+        # 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
+                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.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
+            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.nil? || @socket.closed?
+            @kill = true
+            server = Models::Server.find_or_create(:host => @server, :port => @port)
+            server.connected = false
+            server.save
+            sleep(0.1)
+            connect if restart
+        end
+
+        private
+
+        def populate_servers
+            Models::Server.reverse_order(:priority).each{|s|
+                @servers << s
+            }
+        end
+
+    end
+
+end

data/lib/mod_spox/Sockets.rb

@@ -0,0 +1,226 @@
+['ipaddr',
+ 'iconv',
+ 'mod_spox/Bot',
+ 'mod_spox/Pipeline',
+ 'mod_spox/MessageFactory',
+ 'mod_spox/Socket',
+ 'mod_spox/messages/internal/DCCSocket',
+ 'mod_spox/messages/outgoing/Privmsg'
+].each{|f| require f}
+
+require 'spockets'
+
+module ModSpox
+
+    class Sockets
+
+        attr_reader :irc_socket
+
+        def initialize(bot)
+            @bot = bot
+            @irc_socket = nil
+            @dcc_sockets = []
+            @mapped_sockets = {}
+            @spockets = Spockets::Spockets.new(:pool => bot.pool)
+            @listening_dcc = []
+            @dcc_ports = {:start => 49152, :end => 65535}
+            @dcc_wait = 30
+            @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)
+            @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=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)
+            if(message =~ /::(\S+)::\s:(.+)$/)
+                id = $1.to_i
+                message = $2 + "\r\n"
+                sock_info = @mapped_sockets[id]
+                sock_info[:socket] << message
+            else
+                @irc_socket << message
+            end
+        end
+        
+        def prioritize_message(target, message)
+            @irc_socket.prioritize_message(target, 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}")
+                    @dcc_sockets << client
+                    @mapped_sockets[client.object_id] = {:socket => client, :nick => message.nick}
+                    @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
+                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
+            @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
+        # 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)
+                @spockets.add(socket){|string| process_dcc_string(string, socket)}
+                @mapped_sockets[socket.object_id] = {:socket => socket, :nick => nick}
+                @dcc_sockets << socket
+                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)
+            @spockets.remove(sock)
+            @dcc_sockets.delete(sock)
+            @mapped_sockets.delete(sock.object_id)
+        end
+
+        def process_irc_string(string)
+            if(@queue_messages)
+                @queues[:irc] << string
+            else
+                @irc_socket.process(string)
+            end
+        end
+        
+        def process_dcc_string(string, socket)
+            if(@queue_messages)
+                @queues[:dcc] = {:string => string, :socket => socket}
+            else
+                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
+            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
+
+    end
+end

data/lib/mod_spox/Timer.rb

@@ -0,0 +1,60 @@
+['mod_spox/Logger',
+ 'mod_spox/Pipeline',
+ 'mod_spox/messages/internal/TimerResponse'].each{|f|require f}
+
+module ModSpox
+
+    class Timer
+
+        # timer:: ActionTimer to use
+        # pipeline:: Message pipeline
+        # Creates a timer handler for interactions
+        # with the ActionTimer
+        def initialize(timer, pipeline)
+            @pipeline = pipeline
+            @timer = timer
+            {:Internal_TimerAdd => :add_message,
+             :Internal_TimerRemove => :remove_message,
+             :Internal_TimerClear => :clear}.each_pair do |type,method|
+                @pipeline.hook(self, method, type)
+            end
+        end
+
+        # message:: TimerAdd message
+        # Add a recurring code block
+        def add_message(message)
+            Logger.info("New block is being added to the timer")
+            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)
+            @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
+
+        # Clears all actions in the timer's queue
+        def clear(message=nil)
+            if(message.nil? || message.plugin.nil?)
+                @timer.clear
+            else
+                @timer.clear(message.plugin)
+            end
+        end
+        
+        # stop the timer
+        def stop
+            @timer.stop
+        end
+
+    end
+
+end

data/lib/mod_spox/Version.rb

@@ -0,0 +1,14 @@
+module ModSpox
+    @botversion='0.3.1'
+    @botcodename='potato shotgun'
+    @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

@@ -0,0 +1,19 @@
+require 'mod_spox/handlers/Handler'
+require 'mod_spox/messages/incoming/BadNick'
+module ModSpox
+    module Handlers
+        class BadNick < Handler
+            def initialize(handlers)
+                handlers[RFC[:ERR_ERRONEOUSNICKNAME][:value]] = self
+            end
+            def process(string)
+                if(string =~ /#{RFC[:ERR_ERRONEOUSNICKNAME][:value]}\s\S+\s(\S+)\s:/)
+                    return Messages::Incoming::BadNick.new(string, $1)
+                else
+                    Logger.warn('Failed to process RPL_ERRORONEOUSNICK message')
+                    return nil
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Bounce.rb

@@ -0,0 +1,24 @@
+require 'mod_spox/handlers/Handler'
+require 'mod_spox/messages/incoming/Bounce'
+module ModSpox
+    module Handlers
+        class Bounce < Handler
+            def initialize(handlers)
+                handlers[RFC[:RPL_BOUNCE][:value]] = self
+            end
+            
+            def process(string)
+                begin
+                    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)
+                rescue Object => boom
+                    Logger.error("Failed to parse BOUNCE message: #{orig}")
+                    raise Exceptions::GeneralException.new(boom)
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Created.rb

@@ -0,0 +1,27 @@
+require 'mod_spox/handlers/Handler'
+require 'mod_spox/messages/incoming/Created'
+require 'time'
+module ModSpox
+    module Handlers
+        class Created < Handler
+            def initialize(handlers)
+                handlers[RFC[:RPL_CREATED][:value]] = self
+            end
+            # :not.configured 003 spox :This server was created Tue Mar 24 2009 at 15:42:36 PDT'
+            def process(string)
+                string = string.dup
+                begin
+                    orig = string.dup
+                    2.times{string.slice!(0..string.index(':'))}
+                    4.times{string.slice!(0..string.index(' '))}
+                    time = Time.parse(string)
+                    time = nil if Time.now == time
+                    return time.nil? ? nil : Messages::Incoming::Created.new(orig, time)
+                rescue Object => boom
+                    Logger.error("Failed to parse RPL_CREATED message: #{orig}")
+                    raise Exceptions::GeneralException.new(boom)
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Handler.rb

@@ -0,0 +1,39 @@
+require 'mod_spox/rfc2812'
+require 'mod_spox/Helpers'
+require 'mod_spox/Exceptions'
+module ModSpox
+    module Handlers
+    
+        class Handler
+
+            # handlers:: array of handlers
+            # initialize handler and add self to available
+            # handlers
+            def initialize(handlers)
+                raise Exceptions::NotImplemented.new('Method has not been implemented')
+            end
+
+            # data:: string of data
+            # Process the string and create the proper object
+            def process(data)
+                raise Exceptions::NotImplemented.new('Method has not been implemented')
+            end
+            
+            # data:: any expected data
+            # Preprocessing allows for actions to be taken
+            # while messages are still in a synchronized state
+            def preprocess(data)
+            end
+            
+            protected
+
+            # deprecated. here basically so old handlers
+            # don't break
+            def find_model(string)
+                Helpers.find_model(string)
+            end
+        
+        end
+        
+    end
+end

data/lib/mod_spox/handlers/Invite.rb

@@ -0,0 +1,28 @@
+require 'mod_spox/handlers/Handler'
+require 'mod_spox/messages/incoming/Invite'
+module ModSpox
+    module Handlers
+        class Invite < Handler
+            def initialize(handlers)
+                handlers[:INVITE] = self
+            end
+            # :spax!~spox@host INVITE spox :#m
+            def process(string)
+                orig = string.dup
+                string = string.dup
+                begin
+                    string.slice!(0)
+                    source = find_model(string.slice!(0..string.index('!')-1))
+                    2.times{ string.slice!(0..string.index(' ')) }
+                    target = find_model(string.slice!(0..string.index(' ')-1))
+                    string.slice!(0..string.index(':'))
+                    channel = find_model(string.strip)
+                    return Messages::Incoming::Invite.new(orig, source, target, channel)
+                rescue Object => boom
+                    Logger.error("Failed to parse INVITE message: #{orig}")
+                    raise Exceptions::GeneralException.new(boom)
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/handlers/Join.rb

@@ -0,0 +1,38 @@
+require 'mod_spox/handlers/Handler'
+require 'mod_spox/messages/incoming/Join'
+module ModSpox
+    module Handlers
+        class Join < Handler
+            def initialize(handlers)
+                handlers[:JOIN] = self
+            end
+
+            # :mod_spox!~mod_spox@host JOIN :#m
+            
+            def process(string)
+                orig = string.dup
+                string = string.dup
+                begin
+                    string.slice!(0)
+                    source = string.slice!(0..string.index(' ')-1)
+                    string.slice!(0..string.index(':'))
+                    channel = find_model(string.strip)
+                    nick = find_model(source.slice(0..source.index('!')-1))
+                    nick.source = source.dup
+                    source.slice!(0..source.index('!'))
+                    nick.username = source.slice!(0..source.index('@')-1)
+                    source.slice!(0)
+                    nick.address = source.slice!(0..source.size)
+                    nick.visible = true
+                    nick.save_changes
+                    channel.add_nick(nick)
+                    channel.save
+                    return Messages::Incoming::Join.new(orig, channel, nick)
+                rescue Object => boom
+                    Logger.warn("Failed to parse JOIN message: #{orig}")
+                    raise Exceptions::GeneralException.new(boom)
+                end
+            end
+        end
+    end
+end