spox-mod_spox 0.3.1

data/lib/mod_spox/ConfigurationWizard.rb

@@ -0,0 +1,180 @@
+['etc', 
+ 'mod_spox/Database',
+ 'mod_spox/BotConfig',
+ 'mod_spox/BaseConfig'].each{|f|require f}
+
+
+module ModSpox
+
+    class ConfigurationWizard
+    
+        def initialize
+            @echo = nil
+            @config = Array.new
+            @config_db = Hash.new
+            @stuck_visible = true
+            begin
+                require 'termios'
+                @stuck_visible = false
+            rescue Object => boom
+            end
+        end
+    
+        # Run the configuration wizard
+        def run
+            config = {}
+            puts "*********************************"
+            puts "* mod_spox Configuration Wizard *"
+            puts "*********************************"
+            puts ""
+            config[:irc_server] = get_input('IRC Server: ', '.+', nil)
+            config[:irc_port] = get_input('IRC Port: ', '\d+', '6667')
+            config[:reconnect_wait] = get_input('Reconnect wait time: ', '\d+', 10)
+            config[:bot_nick] = get_input('IRC Nick: ', '[a-zA-Z].*', 'mod_spox')
+            config[:bot_password] = get_input('IRC Nick Password (for nickserv): ', '.*', nil)
+            config[:bot_username] = get_input('IRC Username: ', '.+', 'mod_spox')
+            config[:bot_realname] = get_input('IRC Real Name: ', '.+', 'mod_spox IRC bot')
+            config[:socket_burst] = get_input('Socket burst rate (lines): ', '\d+', '3')
+            config[:socket_burst_in] = get_input('Socket burst time: ', '\d+', '2')
+            config[:socket_burst_delay] = get_input('Socket burst delay: ', '\d+', '2')
+            config[:admin_nick] = get_input('Administator nick: ', '[a-zA-Z].*', nil)
+            config[:admin_password] = get_input('Administrator password: ', '.+', nil)
+            config[:plugin_directory] = get_input('Plugin temp data driectory (bot needs write permission): ', '.+', '/tmp')
+            config[:trigger] = get_input('Default trigger: ', '.+', '!')
+            config[:memcache] = get_input('Use memcache (EXPERIMENTAL): ', '(yes|no)', 'no')
+            valid_connection = false
+            until valid_connection do
+                config[:db_adapter] = get_input('Database type (pgsql|sqlite|mysql): ', '(pgsql|sqlite|mysql)', 'sqlite')
+                unless(config[:db_adapter] == 'sqlite')
+                    config[:db_username] = get_input('Database username: ', '.+', 'mod_spox')
+                    config[:db_password] = get_input('Database password: ', '.*', nil)
+                    config[:db_host] = get_input('Database host: ', '.*', '127.0.0.1')
+                    config[:db_database] = get_input('Database name: ', '.+', 'mod_spox')
+                end
+                begin
+                    print 'Testing database connection... '
+                    config[:db_adapter] == 'sqlite' ? test_connection(config[:db_adapter]) : test_connection(config[:db_adapter], config[:db_username], config[:db_password], config[:db_host], config[:db_database])
+                    puts 'OK'
+                    valid_connection = true
+                rescue Sequel::DatabaseError, URI::InvalidURIError => boom
+                    puts 'Failed'
+                    puts 'Error: Connection to database failed'
+                    puts "Info: #{boom}"
+                rescue Object => boom
+                    puts 'Failed'
+                    puts 'Error: Unexpected error encountered.'
+                    puts "Info: #{boom}"
+                ensure
+                    $stdout.flush
+                end
+            end
+            print "Storing configuration values... "
+            begin
+                save_configuration(config)
+                puts 'OK'
+                puts 'mod_spox is now configured and ready for use'
+            rescue Object => boom
+                puts 'Failed'
+                puts "Error: #{boom}"
+                puts 'Please try running the configuration again'
+            end
+        end
+        
+        def update
+            run
+        end
+        
+        private
+        
+        def test_connection(type, username=nil, password=nil, host=nil, name=nil)
+            case type
+                 when 'mysql'
+                     c = Sequel.mysql(name, :user => username, :password => password, :host => host)
+                     c.test_connection
+                when 'pgsql'
+                    c = Sequel.connect("#{ModSpox.jdbc ? 'jdbc:' : ''}postgres://#{username}:#{password}@#{host}/#{name}")
+                    c.test_connection
+                when 'sqlite'
+                    return true
+            end
+        end
+        
+        # Save our configuration values
+        def save_configuration(uconfig)
+            config = BaseConfig.new(BotConfig[:userconfigpath])
+            uconfig.each_pair do |key,value|
+                config[key] = value if key.to_s =~ /^(db|memcache)/
+            end
+            config.write_configuration
+            ModSpox.initialize_bot
+            require  'mod_spox/models/Models'
+            require 'mod_spox/Helpers'
+            Sequel::Migrator.apply(Database.db, BotConfig[:libpath] + '/migrations')
+            uconfig.each_pair do |key,value|
+                unless key.to_s =~ /^(db|irc|admin|trigger)/
+                    m = Models::Config.find_or_create(:name => key.to_s)
+                    m.value = value
+                    m.save
+                end
+            end
+            s = Models::Server.find_or_create(:host => uconfig[:irc_server], :port => uconfig[:irc_port])
+            n = Models::Nick.find_or_create(:nick => uconfig[:admin_nick])
+            a = Models::Auth.find_or_create(:nick_id => n.pk)
+            g = Models::Group.find_or_create(:name => 'admin')
+            a.add_group(g)
+            a.password = uconfig[:admin_password]
+            a.save
+            t = Models::Trigger.find_or_create(:trigger => uconfig[:trigger])
+            t.active = true
+            t.save
+        end
+        
+        # echo:: echo user input
+        # Turns echoing of user input on or off
+        def input_echo(echo=true)
+            return if echo == @echo || @stuck_visible
+            term = Termios::getattr($stdin)
+            term.c_lflag |= Termios::ECHO if echo
+            term.c_lflag &= ~Termios::ECHO unless echo
+            Termios::setattr($stdin, Termios::TCSANOW, term)
+            @echo = echo
+        end
+        
+        # pattern:: regex response must match
+        # default:: default value if response is empty
+        # echo:: echo user's input
+        # Reads users input
+        def read_input(pattern=nil, default=nil)
+            #input_echo(echo)
+            response = $stdin.readline
+            response.strip!
+            set = response.length > 0
+            unless(pattern.nil?)
+                response = nil unless response =~ /^#{pattern}$/
+            end
+            if(default && !set)
+                response = default
+            end
+            #input_echo(true) unless echo
+            #puts "" unless echo
+            return response
+        end
+        
+        # output:: to send before user input
+        # regex:: pattern user input must match (^ and $ not needed. applied automatically)
+        # echo:: echo user's input
+        # default:: default value if no value is entered
+        def get_input(output, regex, default=nil)
+            response = nil
+            until(response) do
+                print output
+                print "[#{default}]: " unless default.nil?
+                $stdout.flush
+                response = read_input(regex, default)
+            end
+            return response
+        end
+    
+    end
+
+end

data/lib/mod_spox/Database.rb

@@ -0,0 +1,51 @@
+module ModSpox
+
+    class Database
+
+        def Database.db=(database)
+            @@db = nil
+            @@db = database
+        end
+
+        def Database.type=(type)
+            @@type = nil
+            @@type = type
+        end
+
+        def Database.cache=(cache)
+            @@cache = nil
+            @@cache = cache
+        end
+
+        def Database.cache
+            return Database.class_variable_defined?(:@@cache) ? @@cache : nil
+        end
+
+        def Database.type
+            return Database.class_variable_defined?(:@@type) ? @@type : nil
+        end
+
+        def Database.db
+            return Database.class_variable_defined?(:@@db) ? @@db : nil
+        end
+        
+        def Database.reset_connections
+            @@db.disconnect
+        end
+
+        def Database.reconnect
+            begin
+                @@db.test_connection
+                Logger.warn('Database connection appears to be active. Closing.')
+                @@db.disconnect
+            rescue Object => boom
+                Logger.warn('Database connection does not appear to be active.')
+            ensure
+                Logger.warn('Reconnecting to database.')
+                ModSpox.setup_adapter
+            end
+        end
+
+    end
+
+end

data/lib/mod_spox/Exceptions.rb

@@ -0,0 +1,84 @@
+module ModSpox
+    module Exceptions
+
+        class BotException < Exception
+        end
+
+        class GeneralException < Exception
+            attr_reader :original
+            def initialize(o)
+                @original = o
+            end
+            def to_s
+                @original.to_s
+            end
+        end
+        
+        class NotImplemented < BotException
+        end
+    
+        class InvalidType < BotException
+        end
+        
+        class InvalidValue < BotException
+        end
+        
+        class AlreadyRunning < BotException
+        end
+        
+        class NotRunning < BotException
+        end
+        
+        class UnknownKey < BotException
+        end
+        
+        class InstallationError < BotException
+        end
+        
+        class LockedObject < BotException
+        end
+        
+        class TimerInUse < BotException
+        end
+        
+        class EmptyQueue < BotException
+        end
+
+        class Disconnected < BotException
+        end
+
+        class HandlerNotFound < BotException
+            attr_reader :message_type
+            def initialize(type)
+                @message_type = type
+            end
+        end
+
+        class NotInChannel < BotException
+            attr_reader :channel
+            def initialize(channel)
+                @channel = channel
+            end
+            def to_s
+                "Bot is not currently in channel: #{@channel}"
+            end
+        end
+
+        class QuietChannel < BotException
+            attr_reader :channel
+            def initialize(channel)
+                @channel = channel
+            end
+            def to_s
+                "Bot is not allowed to speak in channel: #{@channel}"
+            end
+        end
+
+        class PluginMissing < BotException
+        end
+
+        class PluginFileNotFound < BotException
+        end
+
+    end
+end

data/lib/mod_spox/Helpers.rb

@@ -0,0 +1,122 @@
+['timeout',
+ 'net/http',
+ 'mod_spox/models/Nick',
+ 'mod_spox/models/Channel',
+ 'mod_spox/models/Server',
+ 'mod_spox/models/Models',
+ 'mod_spox/Logger'].each{|f|require f}
+
+module ModSpox
+    module Helpers
+        # secs:: number of seconds
+        # Converts seconds into a human readable string
+        def Helpers.format_seconds(secs)
+            arg = {:year => 29030400,
+                   :month => 2419200,
+                   :week => 604800,
+                   :day => 86400,
+                   :hour => 3600,
+                   :minute => 60,
+                   :second => 1}
+            res = ''
+            arg.each_pair do |k,v|
+                z = (secs / v).to_i
+                next unless z > 0
+                res += " #{z} #{k}#{z == 1 ? '':'s'}"
+                secs = secs % v
+            end
+            res = '0 seconds' if res.empty?
+            return res.strip
+        end
+
+        # bytes:: number of bytes
+        # Converts bytes into easy human readable form
+        # O(1) version by Ryan "pizza_milkshake" Flynn
+        Suff = [
+        "",       # 1024^0
+        "Kilo",   # 1024^1
+        "Mega",   # 1024^2
+        "Giga",   # 1024^3
+        "Tera",   # 1024^4
+        "Peta",   # 1024^5
+        "Exa",    # 1024^6
+        "Zetta",  # 1024^7
+        "Yotta"   # 1024^8
+        ]
+        def Helpers.format_size(bytes)
+            mag = (Math.log(bytes) / Math.log(1024)).floor
+            mag = [ Suff.length - 1, mag ].min
+            val = bytes.to_f / (1024 ** mag)
+            "%7.3f %sbyte%s" % [ val, Suff[mag], val == 1 ? "" : "s" ]
+        end
+
+        # command:: command to execute
+        # timeout:: maximum number of seconds to run
+        # Execute a system command (use with care)
+        def Helpers.safe_exec(command, timeout=10)
+            begin
+                Timeout::timeout(timeout) do
+                    result = `#{command}`
+                end
+            rescue Timeout::Error => boom
+                Logger.warn("Command execution exceeded allowed time (command: #{command} | timeout: #{timeout})")
+                raise boom
+            rescue Object => boom
+                Logger.warn("Command generated an exception (command: #{command} | error: #{boom})")
+                raise boom
+            end
+        end
+
+        # url:: URL to shorten
+        # Gets a tinyurl for given URL
+        def Helpers.tinyurl(url)
+            begin
+                connection = Net::HTTP.new('tinyurl.com', 80)
+                resp, data = connection.get("/api-create.php?url=#{url}")
+                if(resp.code !~ /^200$/)
+                    raise "Failed to make the URL small."
+                end
+                return data.strip
+            rescue Object => boom
+                raise "Failed to process URL. #{boom}"
+            end
+        end
+
+        # string:: name of target
+        # Locates target model and returns it. String can be a nick
+        # or channel name. If the string given does not match the required
+        # pattern for a channel or nick, the string is returned.
+        def Helpers.find_model(string, create=true)
+            result = nil
+            if(string =~ /^[A-Za-z\|\\\{\}\[\]\^\`~\_\-]+[A-Za-z0-9\|\\\{\}\[\]\^\`~\_\-]*$/)
+                result = Models::Nick.find_or_create(:nick => string.downcase)
+            elsif(['&', '#', '+', '!'].include?(string[0]))
+                result = Models::Channel.find_or_create(:name => string.downcase)
+            elsif(Models::Server.filter(:host => string, :connected => true).count > 0)
+                result = Models::Server.filter(:host => string, :connected => true).first
+            else
+                Logger.warn("Failed to match string to model: #{string} -> No match")
+            end
+            return result
+        end
+
+        # string:: string to convert
+        # Converts HTML entities found in a string
+        def Helpers.convert_entities(string)
+            begin
+                require 'htmlentities'
+                @@coder = HTMLEntities.new unless Helpers.class_variable_defined?(:@@coder)
+                return @@coder.decode(string)
+            rescue Object
+                return string
+            end
+        end
+
+        # kind:: (:internal|:incoming|:outgoing)
+        # type:: message type (Example: :Privmsg)
+        # Easy loader for messages
+        def load_message(kind, type)
+            require "mod_spox/messages/#{kind}/#{type}"
+        end
+    end
+end

data/lib/mod_spox/Loader.rb

@@ -0,0 +1,60 @@
+['mod_spox/Exceptions',
+ 'mod_spox/BotConfig',
+ 'mod_spox/BaseConfig',
+ 'mod_spox/Database',
+ 'logger'].each{|f|require f}
+
+module ModSpox
+    
+    # Loads all files needed by the bot
+    def self.initialize_bot(db=nil)
+        setup_adapter(db)
+        check_upgrade
+    end
+    
+    # Setup the DataMapper adapter
+    def self.setup_adapter(db=nil)
+        memcache = false
+        config = BaseConfig.new(BotConfig[:userconfigpath])
+        if(config[:memcache] == 'on')
+            begin
+                require 'memcache'
+                memcache = true
+                Database.cache = MemCache.new('localhost:11211', :namespace => 'modspox')
+            rescue Object => boom
+                puts "FAILED TO LOAD MEMCACHE SUPPORT: #{boom}"
+                # do nothing #
+            end
+        end
+        unless(db.nil?)
+            Database.db = db
+        else
+            case config[:db_adapter]
+                when 'mysql'
+                    Database.db = Sequel.mysql(config[:db_database], :user => config[:db_username],
+                            :password => config[:db_password], :host => config[:db_host], :max_connections => 20)
+                    Database.type = :mysql
+                when 'pgsql'
+                    Database.db = Sequel.connect("#{ModSpox.jdbc ? 'jdbc:' : ''}postgres://#{config[:db_username]}:#{config[:db_password]}@#{config[:db_host]}/#{config[:db_database]}")
+                    Database.type = :pgsql
+                when 'sqlite'
+                    Database.db = Sequel.sqlite("#{BotConfig[:userpath]}/mod_spox.db", :pool_timeout => 20, :timeout => 5000)
+                    Database.type = :sqlite
+            end
+        end
+    end
+    
+    # check if the bot has been upgraded
+    def self.check_upgrade
+        Sequel::Migrator.apply(Database.db, BotConfig[:libpath] + '/migrations')
+        config = BaseConfig.new(BotConfig[:userconfigpath])
+        config[:plugin_upgrade] = 'no'
+        begin
+            config[:plugin_upgrade] = 'yes' if config[:last_version] != ModSpox.botversion
+        rescue Exceptions::UnknownKey => boom
+            config[:plugin_upgrade] = 'yes'
+        end
+        config[:last_version] = ModSpox.botversion
+    end
+    
+end

data/lib/mod_spox/Logger.rb

@@ -0,0 +1,37 @@
+require 'logger'
+module ModSpox
+
+    class Logger
+        
+        def Logger.initialize(logger, level)
+            l = {:info => ::Logger::INFO, :error => ::Logger::ERROR, :warn => ::Logger::WARN, :fatal => ::Logger::FATAL}
+            @@log = logger.is_a?(::Logger) ? logger : nil
+            @@log.level = l[level]
+        end
+        
+        def Logger.warn(s)
+            @@log.warn(s) if Logger.log?
+        end
+        
+        def Logger.info(s)
+            @@log.info(s) if Logger.log?
+        end
+        
+        def Logger.fatal(s)
+            @@log.fatal(s) if Logger.log?
+        end
+        
+        def Logger.error(s)
+            @@log.error(s) if Logger.log?
+        end
+        
+        def Logger.log?
+            Logger.class_variable_defined?(:@@log)
+        end
+
+        def Logger.raw
+            Logger.log? ? @@log : nil
+        end
+        
+    end
+end

data/lib/mod_spox/MessageFactory.rb

@@ -0,0 +1,112 @@
+['mod_spox/handlers/Handler',
+ 'mod_spox/Logger',
+ 'mod_spox/Pipeline'].each{|f|require f}
+
+module ModSpox
+
+    class MessageFactory
+
+        # access to handlers. (only really needed for testing)
+        attr_reader :handlers
+
+        # pipeline:: Message pipeline
+        # Create a new MessageFactory
+        def initialize(pipeline, pool)
+            @pipeline = pipeline
+            @pool = pool
+            @sync_pool = ActionPool::Pool.new(1, 1, nil, 2, Logger.raw)
+            @handlers = Hash.new
+            @available = {}
+            RFC.each_pair{|k,v| @available[v[:value]] = v[:handlers]}
+            @sync = [:RPL_MOTDSTART, :RPL_MOTD, :RPL_ENDOFMOTD, :RPL_WHOREPLY, :RPL_ENDOFWHO,
+                     :RPL_NAMREPLY, :RPL_ENDOFNAMES, :RPL_WHOISUSER, :RPL_WHOISSERVER, :RPL_WHOISOPERATOR,
+                     :RPL_WHOISIDLE, :RPL_WHOISCHANNELS, :RPL_WHOISIDENTIFIED, :RPL_ENDOFWHOIS].map{|s| RFC[s][:value]}
+        end
+
+        # string:: server message to be parsed
+        # Parses messages from server. This is placed in a queue to
+        # be processed thus there is now wait for processing to be
+        # completed.
+        def <<(string)
+            @pool.process{ parse_message(string) }
+        end
+
+        # s:: string from server
+        # determine type of message from server
+        def find_key(s)
+            s = s.dup
+            begin
+                key = nil
+                if(s[0].chr == ':')
+                    s.slice!(0..s.index(' '))
+                    key = s.slice!(0..s.index(' ')-1)
+                else
+                    key = s.slice(0..s.index(' ')-1)
+                end
+                key.strip!
+                key = key.to_sym if key.to_i == 0
+                return key
+            rescue Object
+                Logger.info("Failed to find key for message: #{s}")
+                raise Exceptions::UnknownKey.new
+            end
+        end
+
+        private
+
+        # message:: server message
+        # Parses the server message and passes it to the proper handler
+        def parse_message(message)
+            Logger.info("Processing message: #{message}")
+            loaded = false
+            begin
+                key = find_key(message)
+                if(@handlers.has_key?(key))
+                    Logger.info("Message of type #{key} is now being handled by #{@handlers[key]}")
+                    if(@sync.include?(key))
+                        Logger.info("Message of type #{key} requires synchronized processing")
+                        @sync_pool.process do
+                            message = @handlers[key].process(message)
+                            @pipeline << message unless message.nil?
+                        end
+                    else
+                        @pool.process do
+                            message = @handlers[key].process(message)
+                            @pipeline << message unless message.nil?
+                        end
+                    end
+                else
+                    Logger.error("No handler was found to process message of type: #{key} Message: #{message}")
+                    raise Exceptions::HandlerNotFound.new(key)
+                end
+            rescue Exceptions::HandlerNotFound => boom
+                unless(loaded)
+                    if(@available[boom.message_type])
+                        @available[boom.message_type].each do|f|
+                            require "mod_spox/handlers/#{f}"
+                            klass = ModSpox::Handlers.const_get(f)
+                            if(klass.nil?)
+                                Logger.error("File name does not seem to match class name. Now what? #{boom}")
+                            else
+                                klass.new(@handlers)
+                            end
+                        end
+                        Logger.info("Loaded handler for message type: #{boom.message_type}. Reprocessing message")
+                        loaded = true
+                        retry
+                    end
+                end
+                raise boom
+            rescue Object => boom
+                if(boom.class.to_s == 'SQLite3::BusyException' || boom.class.to_s == 'PGError')
+                    Database.reset_connections
+                    retry
+                else
+                    Logger.warn("Failed to parse message from server: #{boom}\n#{boom.backtrace.join("\n")}")
+                end
+            end
+        end
+
+    end
+
+end