mod_spox 0.2.0 → 0.3.0

data/lib/mod_spox/BotConfig.rb

@@ -20,11 +20,11 @@ module ModSpox
         # :userconfigpath => path to the user configuration file        
         def BotConfig.populate(createdir=true)
             gemname, gem = Gem.source_index.find{|name, spec|
-                spec.name == 'mod_spox' && spec.version.version = $BOTVERSION
+                spec.name == 'mod_spox' && spec.version.version = ModSpox.botversion
             }
             if(gem)
                 p = gem.full_gem_path
-                up = $MOD_SPOX_PATH.nil? ? Etc.getpwnam(Etc.getlogin).dir : $MOD_SPOX_PATH
+                up = ModSpox.mod_spox_path.nil? ? Etc.getpwnam(Etc.getlogin).dir : ModSpox.mod_spox.path
                 @@config = {:basepath => p,
                            :libpath => "#{p}/lib/mod_spox",
                            :datapath => "#{p}/data/mod_spox",

data/lib/mod_spox/ConfigurationWizard.rb

@@ -44,7 +44,7 @@ module ModSpox
             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): ', '(pgsql)', 'pgsql')
+                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)
@@ -63,8 +63,7 @@ module ModSpox
                 rescue Object => boom
                     puts 'Failed'
                     puts 'Error: Unexpected error encountered.'
-                    puts "Info: #{boom.class} #{boom}\n#{boom.backtrace.join("\n")}"
-                    exit 1
+                    puts "Info: #{boom}"
                 ensure
                     $stdout.flush
                 end
@@ -76,7 +75,7 @@ module ModSpox
                 puts 'mod_spox is now configured and ready for use'
             rescue Object => boom
                 puts 'Failed'
-                puts "Error: #{boom}\n#{boom.backtrace.join("\n")}"
+                puts "Error: #{boom}"
                 puts 'Please try running the configuration again'
             end
         end
@@ -89,11 +88,11 @@ module ModSpox
         
         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 'mysql'
+                     c = Sequel.mysql(name, :user => username, :password => password, :host => host)
+                     c.test_connection
                 when 'pgsql'
-                    c = Sequel.connect("#{$JDBC ? 'jdbc:' : ''}postgres://#{username}:#{password}@#{host}/#{name}")
+                    c = Sequel.connect("#{ModSpox.jdbc ? 'jdbc:' : ''}postgres://#{username}:#{password}@#{host}/#{name}")
                     c.test_connection
                 when 'sqlite'
                     return true
@@ -107,7 +106,7 @@ module ModSpox
                 config[key] = value if key.to_s =~ /^(db|memcache)/
             end
             config.write_configuration
-            initialize_bot
+            ModSpox.initialize_bot
             require  'mod_spox/models/Models'
             require 'mod_spox/Helpers'
             Sequel::Migrator.apply(Database.db, BotConfig[:libpath] + '/migrations')
@@ -121,11 +120,12 @@ module ModSpox
             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)
-            a.group = Models::Group.find_or_create(:name => 'admin')
+            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.update_with_params(:active => true)
+            t.active = true
             t.save
         end
         
@@ -177,4 +177,4 @@ module ModSpox
     
     end
 
-end
+end

data/lib/mod_spox/Database.rb

@@ -30,10 +30,7 @@ module ModSpox
         end
         
         def Database.reset_connections
-            Logger.warn('Resetting database connections. Any active connections are being closed.')
-            Database.db.pool.allocated.each_pair do |thread, connection|
-                thread.kill
-            end
+            @@db.disconnect
         end
 
         def Database.reconnect

data/lib/mod_spox/Exceptions.rb

@@ -30,6 +30,32 @@ module ModSpox
         
         class TimerInUse < BotException
         end
+        
+        class EmptyQueue < BotException
+        end
+
+        class Disconnected < BotException
+        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
 
     end
 end

data/lib/mod_spox/Helpers.rb

@@ -3,7 +3,7 @@
  'mod_spox/models/Nick',
  'mod_spox/models/Channel',
  'mod_spox/models/Server',
- 'mod_spox/Cache',
+ 'mod_spox/models/Models',
  'mod_spox/Logger'].each{|f|require f}
 
 module ModSpox
@@ -33,20 +33,20 @@ module ModSpox
         # Converts bytes into easy human readable form
         # O(1) version by Ryan "pizza_milkshake" Flynn
         Suff = [
-        "",       # 1000^0
-        "Kilo",   # 1000^1
-        "Mega",   # 1000^2
-        "Giga",   # 1000^3
-        "Tera",   # 1000^4
-        "Peta",   # 1000^5
-        "Exa",    # 1000^6
-        "Zetta",  # 1000^7
-        "Yotta"   # 1000^8
+        "",       # 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(1000)).floor
+            mag = (Math.log(bytes) / Math.log(1024)).floor
             mag = [ Suff.length - 1, mag ].min
-            val = bytes.to_f / (1000 ** mag)
+            val = bytes.to_f / (1024 ** mag)
             "%7.3f %sbyte%s" % [ val, Suff[mag], val == 1 ? "" : "s" ]
         end
 
@@ -87,68 +87,29 @@ module ModSpox
         # 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)
-            Helpers.initialize_caches
+            result = nil
             if(string =~ /^[A-Za-z\|\\\{\}\[\]\^\`~\_\-]+[A-Za-z0-9\|\\\{\}\[\]\^\`~\_\-]*$/)
-                nick = nil
-                if(@@nick_cache.has_key?(string.downcase.to_sym))
-                    begin
-                        nick = Models::Nick[@@nick_cache[string.downcase.to_sym]]
-                        if(nick.nick.downcase != string.downcase)
-                            Logger.warn("Nick returned from cache invalid. Expecting #{string} but got #{nick.nick}")
-                            nick = nil
-                        end
-                    rescue Object => boom
-                        Logger.info("Failed to grab cached nick: #{boom}")
-                    end
-                end
-                unless(nick)
-                    begin
-                        nick = Models::Nick.locate(string, create)
-                        if(nick.nil?)
-                            Database.reconnect
-                            return string
-                        end
-                    rescue Object => boom
-                        Logger.warn("Caught an error. Assuming the database barfed: #{boom}")
-                        Database.reconnect
-                    end
-                    @@nick_cache[string.downcase.to_sym] = nick.pk if nick.is_a?(Models::Nick)
-                    Logger.info('Nick was retrieved from database')
-                end
-                return nick
-            elsif(string =~ /^[&#+!]/)
-                if(@@channel_cache.has_key?(string.downcase.to_sym))
-                    begin
-                        channel = Models::Channel[@@channel_cache[string.downcase.to_sym]]
-                        if(string.downcase != channel.name.downcase)
-                            Logger.warn("Channel returned from cache invalid. Expecting #{string} but got #{channel.name}")
-                            channel = nil
-                        end
-                    rescue Object => boom
-                        Logger.info("Failed to grab cached channel: #{boom}")
-                    end
-                end
-                unless(channel)
-                    channel = Models::Channel.locate(string, create)
-                    if(channel.nil?)
-                        Database.reconnect
-                        return string
-                    end
-                    @@channel_cache[string.downcase.to_sym] = channel.pk if channel.is_a?(Models::Channel)
-                    Logger.info('Channel was retrieved from database')
-                end
-                return channel
-            elsif(model = Models::Server.filter(:host => string, :connected => true).first)
-                return model
+                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")
-                return string
             end
+            return result
         end
 
-        def Helpers.initialize_caches
-            @@nick_cache = Cache.new(20) unless Helpers.class_variable_defined?(:@@nick_cache)
-            @@channel_cache = Cache.new(5) unless Helpers.class_variable_defined?(:@@channel_cache)
+        # 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
     end
 end

data/lib/mod_spox/Loader.rb

@@ -7,13 +7,13 @@
 module ModSpox
     
     # Loads all files needed by the bot
-    def initialize_bot
-        setup_adapter
+    def self.initialize_bot(db=nil)
+        setup_adapter(db)
         check_upgrade
     end
     
     # Setup the DataMapper adapter
-    def setup_adapter
+    def self.setup_adapter(db=nil)
         memcache = false
         config = BaseConfig.new(BotConfig[:userconfigpath])
         if(config[:memcache] == 'on')
@@ -26,36 +26,35 @@ module ModSpox
                 # do nothing #
             end
         end
-        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("#{$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")
-                Database.type = :sqlite
+        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 check_upgrade
+    def self.check_upgrade
+        Sequel::Migrator.apply(Database.db, BotConfig[:libpath] + '/migrations')
         config = BaseConfig.new(BotConfig[:userconfigpath])
         config[:plugin_upgrade] = 'no'
         begin
-            do_upgrade(config) if config[:last_version] != $BOTVERSION
+            config[:plugin_upgrade] = 'yes' if config[:last_version] != ModSpox.botversion
         rescue Exceptions::UnknownKey => boom
-            do_upgrade(config)
+            config[:plugin_upgrade] = 'yes'
         end
-        config[:last_version] = $BOTVERSION
-    end
-    
-    # perform upgrade tasks
-    def do_upgrade(config)
-        Sequel::Migrator.apply(Database.db, BotConfig[:libpath] + '/migrations')
-        config[:plugin_upgrade] = 'yes'
+        config[:last_version] = ModSpox.botversion
     end
     
 end

data/lib/mod_spox/Logger.rb

@@ -3,32 +3,34 @@ module ModSpox
 
     class Logger
         
-        def Logger.initialize(output=nil, level=:fatal)
-            if(output.nil?)
-                @@log = nil
-            else
-                levels = {:info => Object::Logger::INFO, :warn => Object::Logger::WARN, :fatal => Object::Logger::FATAL}
-                @@log = Object::Logger.new(output)
-                @@log.level = levels.has_key?(level) ? levels[level] : Object::Logger::WARN
-            end
+        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)
-            unless @@log.nil?
-                Pool << lambda{@@log.warn(s)}
-            end
+            @@log.warn(s) if Logger.log?
         end
         
         def Logger.info(s)
-            unless @@log.nil?
-                Pool << lambda{@@log.info(s)}
-            end
+            @@log.info(s) if Logger.log?
         end
         
         def Logger.fatal(s)
-            unless @@log.nil?
-                Pool << lambda{@@log.fatal(s)}
-            end
+            @@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

data/lib/mod_spox/MessageFactory.rb

@@ -1,18 +1,21 @@
 ['mod_spox/handlers/Handler',
  'mod_spox/Logger',
- 'mod_spox/Pipeline',
- 'mod_spox/Pool'].each{|f|require f}
+ '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)
+        def initialize(pipeline, pool)
             @pipeline = pipeline
+            @pool = pool
+            @sync_pool = ActionPool::Pool.new(1, 1, nil, 2, Logger.raw)
             @handlers = Hash.new
-            @lock = Mutex.new
             build_handlers
             @sync = [RPL_MOTDSTART, RPL_MOTD, RPL_ENDOFMOTD, RPL_WHOREPLY, RPL_ENDOFWHO,
                      RPL_NAMREPLY, RPL_ENDOFNAMES, RPL_WHOISUSER, RPL_WHOISSERVER, RPL_WHOISOPERATOR,
@@ -24,7 +27,28 @@ module ModSpox
         # be processed thus there is now wait for processing to be
         # completed.
         def <<(string)
-            Pool << lambda{ parse_message(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
@@ -55,29 +79,31 @@ module ModSpox
         def parse_message(message)
             Logger.info("Processing message: #{message}")
             begin
-                if(message =~ /^:\S+ (\S+)/ || message =~ /^([A-Za-z0-9]+)\s/)
-                    key = $1
-                    key = key.to_sym unless key[0].chr =~ /\d/
-                    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")
-                            Pool << lambda do
-                                @lock.synchronize do
-                                    message = @handlers[key].process(message)
-                                    @pipeline << message unless message.nil?
-                                end
-                            end
-                        else
-                            Pool << lambda do
-                                message = @handlers[key].process(message)
-                                @pipeline << message unless message.nil?
-                            end
+                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}")
                 end
             rescue Object => boom
-                Logger.warn("Failed to parse message from server: #{boom}\n#{boom.backtrace.join("\n")}")
+                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