mod_spox 0.1.0.1 → 0.2.0

data/lib/mod_spox/ConfigurationWizard.rb

@@ -11,26 +11,7 @@ module ModSpox
         def initialize
             @echo = nil
             @config = Array.new
-            @config << {:id => :db_username, :string => 'Database username: ', :regex => '[a-zA-Z].*', :default => 'mod_spox', :value => nil, :echo => true}
-            @config << {:id => :db_password, :string => 'Database password: ', :regex => '.*', :default => nil, :value => nil, :echo => false}
-            @config << {:id => :db_host, :string => 'Database host: ', :regex => '.+', :default => 'localhost', :value => nil, :echo => true}
-            @config << {:id => :db_database, :string => 'Database name: ', :regex => '.+', :default => 'mod_spox', :value => nil, :echo => true}
-            @config << {:id => :db_adapter, :string => 'Database type (mysql|pgsql|sqlite): ', :regex => '(mysql|pgsql|sqlite)', :default => nil, :value => nil, :echo => true}
-            @config << {:id => :irc_server, :string => 'IRC Server: ', :regex => '.+', :default => nil, :value => nil, :echo => true}
-            @config << {:id => :irc_port, :string => 'IRC Port: ', :regex => '[0-9]+', :default => nil, :value => nil, :echo => true}
-            @config << {:id => :reconnect_wait, :string => 'Reconnect wait time: ', :regex => '[0-9]+', :default => '10', :value => nil, :echo => true}
-            @config << {:id => :bot_nick, :string => 'IRC Nick: ', :regex => '[a-zA-Z].*', :default => 'mod_spox', :value => nil, :echo => true}
-            @config << {:id => :bot_password, :string => 'IRC Nick Password: ', :regex => '.*', :default => nil, :value => nil, :echo => false}
-            @config << {:id => :bot_username, :string => 'IRC Username: ', :regex => '.+', :default => 'mod_spox', :value => nil, :echo => true}
-            @config << {:id => :bot_realname, :string => 'IRC Real Name: ', :regex => '.+', :default => 'mod_spox IRC bot', :value => nil, :echo => true}
-            @config << {:id => :socket_burst, :string => 'Socket burst rate (lines): ', :regex => '[0-9]+', :default => '3', :value => nil, :echo => true}
-            @config << {:id => :socket_burst_in, :string => 'Socket burst time: ', :regex => '[0-9]+', :default => '2', :value => nil, :echo => true}
-            @config << {:id => :socket_burst_delay, :string => 'Socket burst delay: ', :regex => '[0-9]+', :default => '2', :value => nil, :echo => true}
-            @config << {:id => :admin_nick, :string => 'Administrator nick: ', :regex => '[a-zA-Z].*', :default => nil, :value => nil, :echo => true}
-            @config << {:id => :admin_password, :string => 'Administrator password: ', :regex => '.+', :default => nil, :value => nil, :echo => false}
-            @config << {:id => :plugin_directory, :string => 'Plugin directory (bot must have write priviliges): ', :regex => '.+', :default => nil, :echo => true}
-            @config << {:id => :trigger, :string => 'Trigger character for plugins: ', :regex => '.', :default => '!', :value => nil, :echo => true}
-            @config << {:id => :memcache, :string => 'Use memcache (EXPERIMENTAL): ', :regex => '(yes|no)', :default => 'no', :value => nil, :echo => true}            
+            @config_db = Hash.new
             @stuck_visible = true
             begin
                 require 'termios'
@@ -41,52 +22,109 @@ module ModSpox
     
         # Run the configuration wizard
         def run
+            config = {}
             puts "*********************************"
             puts "* mod_spox Configuration Wizard *"
             puts "*********************************"
             puts ""
-            @config.each{|v|
-                v[:value] = get_input(v[:string], v[:regex], v[:echo], v[:default])
-            }
+            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): ', '(pgsql)', 'pgsql')
+                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.class} #{boom}\n#{boom.backtrace.join("\n")}"
+                    exit 1
+                ensure
+                    $stdout.flush
+                end
+            end
             print "Storing configuration values... "
-            save_configuration
-            puts "OK"
-            puts "mod_spox is now configured and ready for use"
+            begin
+                save_configuration(config)
+                puts 'OK'
+                puts 'mod_spox is now configured and ready for use'
+            rescue Object => boom
+                puts 'Failed'
+                puts "Error: #{boom}\n#{boom.backtrace.join("\n")}"
+                puts 'Please try running the configuration again'
+            end
+        end
+        
+        def update
+            run
         end
         
         private
         
-        def find(key)
-            @config.each{|c|
-                if(c[:id] == key)
-                    return c[:value]
-                end
-            }
-            return nil
+        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("#{$JDBC ? 'jdbc:' : ''}postgres://#{username}:#{password}@#{host}/#{name}")
+                    c.test_connection
+                when 'sqlite'
+                    return true
+            end
         end
         
         # Save our configuration values
-        def save_configuration
+        def save_configuration(uconfig)
             config = BaseConfig.new(BotConfig[:userconfigpath])
-            @config.each{|value|
-                config[value[:id]] = value[:value] if value[:id].to_s =~ /^(db|memcache)/
-            }
+            uconfig.each_pair do |key,value|
+                config[key] = value if key.to_s =~ /^(db|memcache)/
+            end
             config.write_configuration
             initialize_bot
             require  'mod_spox/models/Models'
             require 'mod_spox/Helpers'
-            create_databases
-            #Migrators.constants.each{|m| Migrators.const_get(m).apply(Database.db, :up)}
-            @config.each{|value|
-                Models::Config[value[:id]] = value[:value] unless value[:id].to_s =~ /^(db|irc|admin|trigger)/
-            }
-            s = Models::Server.find_or_create(:host => find(:irc_server), :port => find(:irc_port))
-            n = Models::Nick.find_or_create(:nick => find(:admin_nick))
+            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)
             a.group = Models::Group.find_or_create(:name => 'admin')
-            a.password = find(:admin_password)
+            a.password = uconfig[:admin_password]
             a.save
-            t = Models::Trigger.find_or_create(:trigger => find(:trigger))
+            t = Models::Trigger.find_or_create(:trigger => uconfig[:trigger])
             t.update_with_params(:active => true)
             t.save
         end
@@ -106,85 +144,36 @@ module ModSpox
         # default:: default value if response is empty
         # echo:: echo user's input
         # Reads users input
-        def read_input(pattern=nil, default=nil, echo=true)
-            input_echo(echo)
+        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 && response.nil? && !set)
+            if(default && !set)
                 response = default
             end
-            input_echo(true) unless echo
-            puts "" unless echo
+            #input_echo(true) unless echo
+            #puts "" unless echo
             return response
         end
         
-        # output:: varchar(255) to send before user input
-        # regex:: pattern user input must match (^ and $ not need. applied automatically)
+        # 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, echo=true, default=nil)
+        def get_input(output, regex, default=nil)
             response = nil
             until(response) do
                 print output
                 print "[#{default}]: " unless default.nil?
-                response = read_input(regex, default, echo)
+                $stdout.flush
+                response = read_input(regex, default)
             end
             return response
         end
-        
-        def create_databases
-            case Database.type
-                when :mysql
-                    Database.db << "CREATE TABLE IF NOT EXISTS nicks (id int not null auto_increment primary key, nick varchar(255) unique not null, username varchar(255), real_name varchar(255), address varchar(255), source varchar(255), connected_at timestamp, connected_to varchar(255), seconds_idle int, visible boolean not null default false, away boolean not null default false, botnick boolean not null default false)"
-                    Database.db << "CREATE TABLE IF NOT EXISTS channels (id int not null auto_increment primary key, name varchar(255) not null, password varchar(255), autojoin boolean not null default false, topic varchar(255), quiet boolean not null default false, parked boolean not null default false)"
-                    Database.db << "CREATE TABLE IF NOT EXISTS auths (id int not null auto_increment primary key, password varchar(255), services boolean not null default false, mask varchar(255) unique, authed boolean not null default false, nick_id int unique references nicks)"
-                    Database.db << "CREATE TABLE IF NOT EXISTS channel_modes (id int not null auto_increment primary key, mode varchar(255) not null, channel_id int unique not null references channels)"
-                    Database.db << "CREATE TABLE IF NOT EXISTS configs (id int not null auto_increment primary key, name varchar(255) unique not null, value varchar(255))"
-                    Database.db << "CREATE TABLE IF NOT EXISTS nick_channels (channel_id int not null unique references channels, nick_id int not null unique not null references nicks, primary key(channel_id, nick_id))"
-                    Database.db << "CREATE TABLE IF NOT EXISTS nick_modes (id integer primary key auto_increment not null, mode varchar(255) not null, nick_id int not null references nicks, channel_id int references channels, unique index nick_modes_nick_id_channel_id_index (nick_id, channel_id))"
-                    Database.db << "CREATE TABLE IF NOT EXISTS servers (id int not null auto_increment primary key, host varchar(255) not null, port int not null default 6667, priority int not null default 0, connected boolean not null default false, unique index servers_server_port_index (server, port))"
-                    Database.db << "CREATE TABLE IF NOT EXISTS settings (id int not null auto_increment primary key, name varchar(255) not null unique, value text)"
-                    Database.db << "CREATE TABLE IF NOT EXISTS signatures (id int not null auto_increment primary key, signature varchar(255) not null, params varchar(255), group_id int default null references groups, method varchar(255) not null, plugin varchar(255) not null, description varchar(255), requirement enum('public', 'private', 'both') default 'both' not null)"
-                    Database.db << "CREATE TABLE IF NOT EXISTS triggers (id int not null auto_increment primary key, `trigger` varchar(255) unique not null, active boolean not null default false)"
-                    Database.db << "CREATE TABLE IF NOT EXISTS groups (id int not null auto_increment primary key, name varchar(255) not null unique)"
-                    Database.db << "CREATE TABLE IF NOT EXISTS auth_groups (auth_id int not null references auths, group_id int not null references groups, primary key(auth_id, group_id))"
-                when :pgsql
-                    Database.db << "CREATE TABLE nicks (id serial not null primary key, nick varchar(255) unique not null, username varchar(255), real_name varchar(255), address varchar(255), source varchar(255), connected_at timestamp, connected_to varchar(255), seconds_idle integer, visible boolean not null default false, away boolean not null default false, botnick boolean not null default false)"
-                    Database.db << "CREATE INDEX nick_nicks_lower on nicks (lower(nick))"
-                    Database.db << "CREATE TABLE channels (id serial not null primary key, name varchar(255) unique not null, password varchar(255), autojoin boolean not null default false, topic varchar(255), quiet boolean not null default false, parked boolean not null default false)"
-                    Database.db << "CREATE TABLE auths (id serial not null primary key, password varchar(255), services boolean not null default false, mask varchar(255) unique, authed boolean not null default false, nick_id integer unique references nicks)"
-                    Database.db << "CREATE TABLE groups (id serial not null primary key, name varchar(255) unique not null)"
-                    Database.db << "CREATE TABLE channel_modes (id serial not null primary key, mode varchar(255) not null, channel_id integer unique not null references channels)"
-                    Database.db << "CREATE TABLE configs (id serial not null primary key, name varchar(255) unique not null, value text)"
-                    Database.db << "CREATE TABLE nick_channels (channel_id integer not null references channels, nick_id integer not null references nicks, primary key(nick_id, channel_id))"
-                    Database.db << "CREATE TABLE nick_modes (id serial not null primary key, mode varchar(255) not null, nick_id integer not null references nicks, channel_id integer references channels, unique (nick_id, channel_id))"
-                    Database.db << "CREATE TABLE servers (id serial not null primary key, host varchar(255) not null, port integer not null default 6667, priority integer not null default 0, connected boolean not null default false, unique (host, port))"
-                    Database.db << "CREATE TABLE signatures (id serial not null primary key, signature varchar(255) not null, params varchar(255), group_id integer default null references groups, method varchar(255) not null, plugin varchar(255) not null, description varchar(255), requirement varchar(255) default 'both' not null)"
-                    Database.db << "CREATE TABLE settings (id serial not null primary key, name varchar(255) unique not null, value text)"
-                    Database.db << "CREATE TABLE triggers (id serial not null primary key, trigger varchar(255) unique not null, active boolean not null default false)"
-                    Database.db << "CREATE TABLE auth_groups (auth_id integer not null references auths, group_id integer not null references groups, primary key (auth_id, group_id))"
-                when :sqlite
-                    Database.db << "CREATE TABLE if not exists nicks (id integer PRIMARY KEY AUTOINCREMENT, nick string UNIQUE NOT NULL COLLATE NOCASE, username string, real_name string, address string, source string, connected_at timestamp, connected_to string, seconds_idle integer, visible boolean NOT NULL DEFAULT 'f', away boolean NOT NULL DEFAULT 'f', botnick boolean NOT NULL DEFAULT 'f')"
-                    Database.db << "CREATE TABLE if not exists channels (id integer PRIMARY KEY AUTOINCREMENT, name string UNIQUE NOT NULL COLLATE NOCASE, password string, autojoin boolean NOT NULL DEFAULT 'f', topic string, quiet boolean NOT NULL DEFAULT 'f', parked boolean NOT NULL DEFAULT 'f')"
-                    Database.db << "CREATE TABLE if not exists auths (id integer PRIMARY KEY AUTOINCREMENT, password string, services boolean NOT NULL DEFAULT 'f', mask string UNIQUE, authed boolean NOT NULL DEFAULT 'f', nick_id integer UNIQUE REFERENCES nicks)"
-                    Database.db << "CREATE TABLE if not exists channel_modes (id integer PRIMARY KEY AUTOINCREMENT, mode string NOT NULL, channel_id integer UNIQUE NOT NULL REFERENCES channels)"
-                    Database.db << "CREATE TABLE if not exists configs (id integer PRIMARY KEY AUTOINCREMENT, name string UNIQUE NOT NULL, value string)"
-                    Database.db << "CREATE TABLE if not exists nick_channels (channel_id integer NOT NULL REFERENCES channels, nick_id integer NOT NULL REFERENCES nicks, primary key (channel_id, nick_id))"
-                    Database.db << "CREATE TABLE if not exists nick_modes (id integer PRIMARY KEY AUTOINCREMENT, mode string NOT NULL, nick_id integer NOT NULL REFERENCES nicks, channel_id integer REFERENCES channels)"
-                    Database.db << "CREATE UNIQUE INDEX if not exists nick_modes_nick_id_channel_id_index ON nick_modes (nick_id, channel_id)"
-                    Database.db << "CREATE TABLE if not exists servers (id integer primary key autoincrement, host string NOT NULL, port integer NOT NULL DEFAULT 6667, priority integer NOT NULL DEFAULT 0, connected boolean NOT NULL DEFAULT 'f')"
-                    Database.db << "CREATE UNIQUE INDEX if not exists servers_host_port_index on servers (host, port)"
-                    Database.db << "CREATE TABLE if not exists settings (id integer PRIMARY KEY AUTOINCREMENT, name string UNIQUE NOT NULL, value text)"
-                    Database.db << "CREATE TABLE if not exists signatures (id integer PRIMARY KEY AUTOINCREMENT, signature string NOT NULL UNIQUE, params string, group_id integer DEFAULT NULL REFERENCES groups, method string NOT NULL, plugin string NOT NULL, description varchar(255), requirement varchar(255) not null default 'both')"
-                    Database.db << "CREATE TABLE if not exists triggers (id integer PRIMARY KEY AUTOINCREMENT, trigger string UNIQUE NOT NULL, active boolean NOT NULL DEFAULT 'f')"            
-                    Database.db << "CREATE TABLE if not exists groups (id integer PRIMARY KEY AUTOINCREMENT, name string UNIQUE NOT NULL COLLATE NOCASE)"
-                    Database.db << "CREATE TABLE if not exists auth_groups(auth_id integer REFERENCES auths, group_id integer REFERENCES groups)"
-            end
-        end
     
     end
 

data/lib/mod_spox/Database.rb

@@ -1,34 +1,54 @@
 module ModSpox
 
     class Database
-    
-        def self.db=(database)
+
+        def Database.db=(database)
             @@db = nil
             @@db = database
         end
-        
-        def self.type=(type)
+
+        def Database.type=(type)
             @@type = nil
             @@type = type
         end
-        
-        def self.cache=(cache)
+
+        def Database.cache=(cache)
             @@cache = nil
             @@cache = cache
         end
-        
-        def self.cache
+
+        def Database.cache
             return Database.class_variable_defined?(:@@cache) ? @@cache : nil
         end
-        
-        def self.type
+
+        def Database.type
             return Database.class_variable_defined?(:@@type) ? @@type : nil
         end
-        
-        def self.db
+
+        def Database.db
             return Database.class_variable_defined?(:@@db) ? @@db : nil
         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
+        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/Helpers.rb

@@ -11,21 +11,45 @@ module ModSpox
         # secs:: number of seconds
         # Converts seconds into a human readable string
         def Helpers.format_seconds(secs)
-            str = []
-            d = (secs / 86400).to_i
-            secs = secs % 86400
-            h = (secs / 3600).to_i
-            secs = secs % 3600
-            m = (secs / 60).to_i
-            secs = secs % 60
-            {:day => d, :hour => h, :minute => m, :second => secs}.each_pair do |type, value|
-                if(value > 0)
-                    str << "#{value} #{type}#{value == 1 ? '':'s'}"
-                end
+            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
-            return str.join(' ')
+            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 = [
+        "",       # 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
+        ]
+        def Helpers.format_size(bytes)
+            mag = (Math.log(bytes) / Math.log(1000)).floor
+            mag = [ Suff.length - 1, mag ].min
+            val = bytes.to_f / (1000 ** 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)
@@ -35,32 +59,29 @@ module ModSpox
                     result = `#{command}`
                 end
             rescue Timeout::Error => boom
-                Logger.log("Command execution exceeded allowed time (command: #{command} | timeout: #{timeout})")
+                Logger.warn("Command execution exceeded allowed time (command: #{command} | timeout: #{timeout})")
+                raise boom
             rescue Object => boom
-                Logger.log("Command generated an exception (command: #{command} | error: #{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("/create.php?url=#{url}", nil)
+                resp, data = connection.get("/api-create.php?url=#{url}")
                 if(resp.code !~ /^200$/)
                     raise "Failed to make the URL small."
                 end
-                data.gsub!(/[\n\r]/, '')
-                if(data =~ /<input type=hidden name=tinyurl value="(.+?)">/)
-                    return $1
-                else
-                    raise "Failed to locate the small URL."
-                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
@@ -68,55 +89,63 @@ module ModSpox
         def Helpers.find_model(string, create=true)
             Helpers.initialize_caches
             if(string =~ /^[A-Za-z\|\\\{\}\[\]\^\`~\_\-]+[A-Za-z0-9\|\\\{\}\[\]\^\`~\_\-]*$/)
-                Logger.log("Model: #{string} -> Nick", 30)
                 nick = nil
                 if(@@nick_cache.has_key?(string.downcase.to_sym))
                     begin
                         nick = Models::Nick[@@nick_cache[string.downcase.to_sym]]
-                        Logger.log("Handler cache hit for nick: #{string}", 30)
                         if(nick.nick.downcase != string.downcase)
-                            Logger.log("Nick returned from cache invalid. Expecting #{string} but got #{nick.nick}", 30)
+                            Logger.warn("Nick returned from cache invalid. Expecting #{string} but got #{nick.nick}")
                             nick = nil
                         end
                     rescue Object => boom
-                        Logger.log("Failed to grab cached nick: #{boom}", 30)
+                        Logger.info("Failed to grab cached nick: #{boom}")
                     end
                 end
                 unless(nick)
-                    nick = Models::Nick.locate(string, create)
+                    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.log("Nick was retrieved from database", 30)
+                    Logger.info('Nick was retrieved from database')
                 end
                 return nick
             elsif(string =~ /^[&#+!]/)
-                Logger.log("Model: #{string} -> Channel", 30)
                 if(@@channel_cache.has_key?(string.downcase.to_sym))
                     begin
                         channel = Models::Channel[@@channel_cache[string.downcase.to_sym]]
-                        Logger.log("Handler cache hit for channel: #{string}", 30)
                         if(string.downcase != channel.name.downcase)
-                            Logger.log("Channel returned from cache invalid. Expecting #{string} but got #{channel.name}", 30)
+                            Logger.warn("Channel returned from cache invalid. Expecting #{string} but got #{channel.name}")
                             channel = nil
                         end
                     rescue Object => boom
-                        Logger.log("Failed to grab cached channel: #{boom}", 30)
+                        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.log("Channel was retrieved from database", 30)
+                    Logger.info('Channel was retrieved from database')
                 end
                 return channel
             elsif(model = Models::Server.filter(:host => string, :connected => true).first)
-                Logger.log("Model: #{string} -> Server", 30)
                 return model
             else
-                Logger.log("FAIL Model: #{string} -> No match", 30)
+                Logger.warn("Failed to match string to model: #{string} -> No match")
                 return string
             end
         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)

data/lib/mod_spox/Loader.rb

@@ -1,13 +1,15 @@
 ['mod_spox/Exceptions',
  'mod_spox/BotConfig',
  'mod_spox/BaseConfig',
- 'mod_spox/Database'].each{|f|require f}
+ 'mod_spox/Database',
+ 'logger'].each{|f|require f}
 
 module ModSpox
     
     # Loads all files needed by the bot
     def initialize_bot
         setup_adapter
+        check_upgrade
     end
     
     # Setup the DataMapper adapter
@@ -27,15 +29,33 @@ module ModSpox
         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])
+                        :password => config[:db_password], :host => config[:db_host], :max_connections => 20)
                 Database.type = :mysql
             when 'pgsql'
-                Database.db = Sequel.open("postgres://#{config[:db_username]}:#{config[:db_password]}@#{config[:db_host]}/#{config[:db_database]}")
+                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.db = Sequel.sqlite("#{BotConfig[:userpath]}/mod_spox.db")
                 Database.type = :sqlite
         end
     end
-
+    
+    # check if the bot has been upgraded
+    def check_upgrade
+        config = BaseConfig.new(BotConfig[:userconfigpath])
+        config[:plugin_upgrade] = 'no'
+        begin
+            do_upgrade(config) if config[:last_version] != $BOTVERSION
+        rescue Exceptions::UnknownKey => boom
+            do_upgrade(config)
+        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'
+    end
+    
 end