mod_spox 0.2.0 → 0.3.0

data/data/mod_spox/plugins/Helper.rb

@@ -4,17 +4,15 @@ class Helper < ModSpox::Plugin
 
     def initialize(pipeline)
         super(pipeline)
-        Signature.find_or_create(:signature => 'help', :plugin => name, :method => 'default_help',
-            :description => 'Display default help information')
-        Signature.find_or_create(:signature => 'help (\S+)', :plugin => name, :method => 'plugin_help',
-            :description => 'Display help information from given plugin').params = [:plugin]
+        add_sig(:sig => 'help', :method => :default_help, :desc => 'Display default help information')
+        add_sig(:sig => 'help (\S+)', :method => :plugin_help, :desc => 'Display help information from given plugin', :params => [:plugin])
     end
 
     def default_help(message, params)
         plugins = Signature.select(:plugin).map(:plugin)
         plugins.uniq!
         reply message.replyto, "Plugins currently available for help: #{plugins.sort.join(', ')}"
-        reply message.replyto, "Request help on a plugin: !help Plugin"
+        reply message.replyto, "Request help on a plugin: #{Models::Trigger.filter(:active => true).first.trigger}help Plugin"
     end
 
     def plugin_help(message, params)
@@ -29,6 +27,7 @@ class Helper < ModSpox::Plugin
                 help << "\2Parameters:\2 [#{sig.params.join(' | ')}]" if sig.params
                 help << "\2Auth Group:\2 #{Group[sig.group_id].name}" if sig.group_id
                 help << "\2Description:\2 #{sig.description}" if sig.description
+                help << "\2Requirement:\2 #{['public', 'private'].include?(sig.requirement) ? sig.requirement : 'both'}"
                 output << help.join(' ')
             end
             if(message.is_dcc?)
@@ -37,7 +36,7 @@ class Helper < ModSpox::Plugin
                 reply message.source, output
             end
         else
-            Signature.all.each{|s| sigs << s.plugin if /#{s.signature.gsub(/\s.*$/, '')}/ =~ params[:plugin]}
+            Signature.all.each{|s| sigs << s.plugin if /#{s.signature.gsub(/(\s|\().*$/, '')}/ =~ params[:plugin]}
             if(sigs.count > 0)
                 sigs.uniq!
                 reply message.replyto, "Possible plugin matches for \2#{params[:plugin]}\2: #{sigs.sort.join(', ')}"

data/data/mod_spox/plugins/Initializer.rb

@@ -12,30 +12,20 @@ class Initializer < ModSpox::Plugin
     # message:: ModSpox::Messages::Internal::BotInitialized
     # Instructs bot to connect to server
     def connect(message)
-        populate_servers if @servers.empty?
-        s = @servers.pop
-        @pipeline << Messages::Internal::EstablishConnection.new(s.host, s.port)
+        @pipeline << Messages::Internal::EstablishConnection.new
     end
     
     # message:: ModSpox::Messages::Internal::Connected
     # Send bot information to server when connection is established
     def send_info(message)
-        @pipeline << Messages::Outgoing::Nick.new(Models::Config[:bot_nick])
-        @pipeline << Messages::Outgoing::User.new(Models::Config[:bot_username], Models::Config[:bot_realname], 8)    
+        @pipeline << Messages::Outgoing::Nick.new(Models::Config.val(:bot_nick))
+        @pipeline << Messages::Outgoing::User.new(Models::Config.val(:bot_username), Models::Config.val(:bot_realname), 8)
     end
     
     # message:: ModSpox::Messages::Internal::ConnectionFailed or ModSpox::Messages::Internal::Disconnected
     # Reconnect to server on disconnection or connection failure
     def reconnect(message)
-        @pipeline << Messages::Internal::TimerAdd.new(self, Models::Config[:reconnect_wait].to_i, nil, true){ connect(nil) }
-    end
-    
-    private
-    
-    def populate_servers
-        Models::Server.reverse_order(:priority).each{|s|
-            @servers << s
-        }
+        @pipeline << Messages::Internal::Reconnect.new
     end
 
 end

data/data/mod_spox/plugins/Joiner.rb

@@ -2,7 +2,7 @@ class Joiner < ModSpox::Plugin
     def initialize(pipeline)
         super(pipeline)
         admin = Models::Group.filter(:name => 'admin').first
-        Models::Signature.find_or_create(:signature => 'join (\S+)', :plugin => name, :method => 'join', :group_id => admin.pk).params = [:channel]
+        add_sig(:sig => 'join (\S+)', :method => :join, :group => admin, :params => [:channel])
         @pipeline.hook(self, :send_who, :Incoming_Join)
     end
     

data/data/mod_spox/plugins/Nicker.rb

@@ -0,0 +1,13 @@
+class Nicker < ModSpox::Plugin
+    def initialize(pipeline)
+        super(pipeline)
+        admin = Models::Group.filter(:name => 'admin').first
+        add_sig(:sig => 'nick (\S+)', :method => :change_nick, :group => admin, :params => [:nick])
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # Join the given channel
+    def change_nick(message, params)
+        @pipeline << Messages::Outgoing::Nick.new(params[:nick])
+    end
+end

data/data/mod_spox/plugins/Parter.rb

@@ -3,8 +3,8 @@ class Parter < ModSpox::Plugin
     def initialize(pipeline)
         super(pipeline)
         admin = Models::Group.filter(:name => 'admin').first
-        Models::Signature.find_or_create(:signature => 'part (\S+)', :plugin => name, :method => 'part', :group_id => admin.pk).params = [:channel]
-        Models::Signature.find_or_create(:signature => 'part', :plugin => name, :method => 'direct_part', :group_id => admin.pk)
+        add_sig(:sig => 'part (\S+)', :method => :part, :group => admin, :params => [:channel])
+        add_sig(:sig => 'part', :method => :direct_part, :group => admin)
     end
     
     # message:: ModSpox::Messages::Incoming::Privmsg

data/data/mod_spox/plugins/Permissions.rb

@@ -0,0 +1,60 @@
+class Permissions < ModSpox::Plugin
+
+    def initialize(pipe)
+        super
+        admin = Models::Group.find_or_create(:name => 'admin')
+        add_sig(:sig => 'perm (\S+)', :group => admin, :method => :show_perm, :desc => 'Display permissions for plugin', :params => [:plugin])
+        add_sig(:sig => 'perm (\d+) (\S+)', :group => admin, :method => :set_perm, :desc => 'Sets permission for signature with given ID', :params => [:id, :group])
+        add_sig(:sig => 'group add (\S+)', :group => admin, :method => :add_group, :desc => 'Add a new authentication group', :params => [:group])
+        add_sig(:sig => 'invalid', :group => admin, :method => :invalid, :desc => 'foobar')
+    end
+    
+    def show_perm(m, params)
+        output = ["Permissions for signatures owned by \2#{params[:plugin]}\2"]
+        Models::Signature.filter(:plugin => params[:plugin]).each do |s|
+            g = s.group
+            output << "[#{s.pk}] \2#{g.is_a?(Models::Group) ? g.name : 'unset'}\2 - #{s.signature} - #{s.description}"
+        end
+        if(output.size > 1)
+            reply m.replyto, output
+        else
+            error m.replyto, "Failed to locate signatures for given plugin: #{params[:plugin]}"
+        end
+    end
+    
+    def set_perm(m, params)
+        s = Models::Signature[params[:id].to_i]
+        if(s)
+            if(params[:group] == 'none')
+                g = true
+            else
+                g = Models::Group.filter(:name => params[:group]).first
+            end
+            if(g)
+                s.group_id = g.is_a?(Models::Group) ? g.pk : nil
+                s.save
+                information m.replyto, "Signature with ID #{s.pk} has been updated to group: #{g.is_a?(Models::Group) ? g.name : 'unset'}"
+            else
+                error m.replyto, "Group name is invalid. If it is a new group, add it first. (#{params[:group]})"
+            end
+        else
+            error m.replyto, "Failed to find signature with ID: #{params[:id]}"
+        end
+    end
+    
+    def add_group(m, params)
+        begin
+            raise 'Invalid group name: none' if params[:group] == 'none'
+            Models::Group.find_or_create(:name => params[:group])
+            information m.replyto, "New group \2#{params[:group]}\2 is now available"
+        rescue Object => boom
+            error m.replyto, "Unknown error when adding new group: #{params[:group]}"
+        end
+    end
+    
+    def invalid(m, params)
+        Models::Signature.dataset.update(:enabled => false)
+        information m.replyto, 'ok'
+    end
+
+end

data/data/mod_spox/plugins/PluginLoader.rb

@@ -3,16 +3,11 @@ class PluginLoader < ModSpox::Plugin
     def initialize(pipeline)
         super(pipeline)
         admin = Models::Group.filter(:name => 'admin').first
-        Models::Signature.find_or_create(:signature => 'plugins available', :plugin => name, :method => 'available_plugins',
-            :group_id => admin.pk, :description => 'List all available plugins')
-        Models::Signature.find_or_create(:signature => 'plugins loaded', :plugin => name, :method => 'loaded_plugins',
-            :group_id => admin.pk, :description => 'List all plugins currently loaded')
-        Models::Signature.find_or_create(:signature => 'plugins load (\S+)', :plugin => name, :method => 'load_plugin',
-            :group_id => admin.pk, :description => 'Load the given plugin').params = [:plugin]
-        Models::Signature.find_or_create(:signature => 'plugins unload (\S+)', :plugin => name, :method => 'unload_plugin',
-            :group_id => admin.pk, :description => 'Unload given plugin').params = [:plugin]
-        Models::Signature.find_or_create(:signature => 'plugins reload ?(\S+)?', :plugin => name, :method => 'reload_plugin',
-            :group_id => admin.pk, :description => 'Reload single plugin or all plugins if names not provided').params = [:plugin]
+        add_sig(:sig => 'plugins available', :method => :available_plugins, :group => admin, :desc => 'List all available plugins')
+        add_sig(:sig => 'plugins loaded', :method => :loaded_plugins, :group => admin, :desc => 'List all plugins currently loaded')
+        add_sig(:sig => 'plugins load (\S+)', :method => :load_plugin, :group => admin, :desc => 'Load the given plugin', :params => [:plugin])
+        add_sig(:sig => 'plugins unload (\S+)', :method => :unload_plugin, :group => admin, :desc => 'Unload given plugin', :params => [:plugin])
+        add_sig(:sig => 'plugins reload ?(\S+)?', :method => :reload_plugin, :group => admin, :desc => 'Reload single plugin or all plugins if names not provided', :params => [:plugin])
         @pipeline.hook(self, :get_module, :Internal_PluginModuleResponse)
         @plugins_mod = nil
     end
@@ -93,7 +88,7 @@ class PluginLoader < ModSpox::Plugin
 
     # Upgrades extra plugins to latest version
     def extras_upgrade
-        Logger.info("Starting plugin upgrade to current version: #{$BOTVERSION}")
+        Logger.info("Starting plugin upgrade to current version: #{ModSpox.botversion}")
         extras = plugin_discovery(BotConfig[:pluginextraspath])
         pl = plugin_list
         extras.keys.each{|d| extras.delete(d) unless pl.include?(d)}
@@ -107,7 +102,7 @@ class PluginLoader < ModSpox::Plugin
         extras.each do |name, path|
             @pipeline << Messages::Internal::PluginLoadRequest.new(self, path)
         end
-        Logger.info("Plugin upgrade is now complete. Upgraded to version: #{$BOTVERSION}")
+        Logger.info("Plugin upgrade is now complete. Upgraded to version: #{ModSpox.botversion}")
     end
 
     private

data/data/mod_spox/plugins/Ponger.rb

@@ -2,7 +2,16 @@ class Ponger < ModSpox::Plugin
 
     def initialize(pipeline)
         super(pipeline)
+        @lag = nil
+        @last = nil
+        @attempts = 0
+        add_sig(:sig => 'lag', :method => :print_lag, :desc => 'Shows bot\'s current lag to server')
         @pipeline.hook(self, :ping, :Incoming_Ping)
+        @pipeline.hook(self, :get_lag_pong, :Incoming_Pong)
+        @lock = Mutex.new
+        @pipeline.hook(self, :check_start_ponger, :Internal_PluginsReady)
+        @running = false
+        send_lag_ping
     end
     
     # message:: ModSpox::Messages::Incoming::Ping
@@ -10,5 +19,47 @@ class Ponger < ModSpox::Plugin
     def ping(message)
         @pipeline << Messages::Outgoing::Pong.new(message.server, message.string)
     end
+    
+    def send_lag_ping
+        if(@attempts > 5)
+            @pipeline << Messages::Internal::Reconnect.new
+            @lag = nil
+            @last = nil
+            @attempts = 0
+        else
+            t = Time.now
+            @last = t.to_f.to_s
+            @pipeline << Messages::Outgoing::Ping.new("#{@last}")
+            @attempts += 1
+        end
+    end
+    
+    def get_lag_pong(m)
+        @lock.synchronize do
+            t = m.string.to_f
+            return unless m.string == @last
+            @lag = Time.now.to_f - t
+            @last = nil
+            @attempts = 0
+        end
+    end
+    
+    def print_lag(m, params)
+        if(@lag.nil?)
+            warning m.replyto, 'Lag time currently unavailable'
+        else
+            information m.replyto, "Current lag time: #{sprintf('%0.4f', @lag)} seconds"
+        end
+    end
+    
+    def start_ponger(m)
+        @running = true
+        send_lag_ping
+        @pipeline << Messages::Internal::TimerAdd.new(self, 60){ send_lag_ping }
+    end
+
+    def check_start_ponger(m)
+        @pipeline << Messages::Internal::TimerAdd.new(self, 30, nil, true){ @lock.synchronize{start_ponger(nil) unless @running} }
+    end
 
 end

data/data/mod_spox/plugins/Quitter.rb

@@ -2,8 +2,7 @@ class Quitter < ModSpox::Plugin
 
     def initialize(pipeline)
         super(pipeline)
-        Models::Signature.find_or_create(:signature => 'quit(\s.+)?', :plugin => name, :method => 'quit',
-            :group_id => Models::Group.filter(:name => 'admin').first.pk).params = [:channel, :message]
+        add_sig(:sig => 'quit(\s.+)?', :method => :quit, :group => Models::Group.filter(:name => 'admin').first, :params => [:channel, :message])
     end
 
     # message:: ModSpox::Messages::Incoming::Privmsg

data/data/mod_spox/plugins/Servers.rb

@@ -0,0 +1,57 @@
+class Servers < ModSpox::Plugin
+    def initialize(pipeline)
+        super
+        admin = Models::Group.find_or_create(:name => 'admin')
+        add_sig(:sig => 'servers list', :method => :list, :group => admin, :desc => 'Show server list')
+        add_sig(:sig => 'servers add (\S+) (\d+)( \d+)?', :method => :add, :group => admin, :desc => 'Add server to list', :params => [:server, :port, :prio])
+        add_sig(:sig => 'servers del (\d+)', :method => :remove, :group => admin, :desc => 'Remove server from list', :params => [:id])
+        add_sig(:sig => 'servers prio (\d+) (\+|\-|\d+)', :method => :prio, :group => admin, :desc => 'Prioritize server', :params => [:id, :move])
+    end
+
+    def list(m, params)
+        output = ["\2Server list:\2"]
+        Models::Server.reverse_order(:priority).each do |s|
+            output << "\2[#{s.id}]\2 #{s.host}:#{s.port} \2Priority:\2 #{s.priority}"
+        end
+        reply m.replyto, output
+    end
+
+    def add(m, params)
+        begin
+            s = Models::Server.new(:host => params[:server], :port => params[:port].to_i)
+            s.priority = params[:prio].to_i if params[:prio]
+            s.save
+            information m.replyto, "New server has been added: #{params[:server]}:#{params[:port]}"
+        rescue Object => boom
+            error m.replyto, "Failed to add new server. Reason: #{boom}"
+        end
+    end
+
+    def remove(m, params)
+        begin
+            raise "List must contain one server" unless Models::Server.count > 1
+            Models::Server[params[:id].to_i].destroy
+            information m.replyto, 'Server has been removed'
+        rescue Object => boom
+            error m.replyto, "Failed to remove server. Reason: #{boom}"
+        end
+    end
+
+    def prio(m, params)
+        begin
+            s = Models::Server[params[:id].to_i]
+            if(params[:move] == '+')
+                s.priority += 1
+            elsif(params[:move] == '-')
+                s.priority -= 1 if s.priority > 0
+            else
+                s.priority = params[:move].to_i
+            end
+            s.save_changes
+            information m.replyto, 'Server priority has been updated.'
+        rescue Object => boom
+            error m.replyto, "Failed to update priority. Reason: #{boom}"
+        end
+    end
+    
+end

data/data/mod_spox/plugins/Status.rb

@@ -4,6 +4,7 @@ class Status < ModSpox::Plugin
         super
         add_sig(:sig => 'status', :method => :status, :desc => 'Show current status')
         add_sig(:sig => 'version', :method => :version, :desc => 'Show version information')
+        add_sig(:sig => 'VERSION', :method => :version, :desc => 'Show version information')
         @pipeline.hook(self, :get_status, :Internal_StatusResponse)
         @resp = []
     end
@@ -14,13 +15,13 @@ class Status < ModSpox::Plugin
     end
     
     def version(message, params)
-        reply message.replyto, "mod_spox IRC bot - Version: \2#{$BOTVERSION}\2 (#{$BOTCODENAME}) [http://modspox.rubyforge.org]"
+        reply message.replyto, "mod_spox IRC bot - Version: \2#{ModSpox.botversion}\2 (#{ModSpox.botcodename}) [http://modspox.rubyforge.org]"
     end
     
     def get_status(m)
         @resp.uniq!
         @resp.each do |c|
-            reply c, "\2Status:\2 \2Uptime:\2 #{m.status[:uptime]} \2Plugins:\2 #{m.status[:plugins]} loaded \2Lines sent:\2 #{m.status[:sent]} \2Lines Received:\2 #{m.status[:received]}"            
+            reply c, "\2Status:\2 \2Uptime:\2 #{m.status[:uptime]} \2Plugins:\2 #{m.status[:plugins]} loaded \2Socket Connected:\2 #{m.status[:socket_connect].strftime("%Y/%m/%d-%H:%M:%S")} \2Lines sent:\2 #{m.status[:sent]} \2Lines Received:\2 #{m.status[:received]}"            
             @resp.delete(c)
         end
     end

data/data/mod_spox/plugins/Triggers.rb

@@ -5,12 +5,12 @@ include Messages::Outgoing
     def initialize(pipeline)
         super(pipeline)
         admin = Models::Group.filter(:name => 'admin').first
-        Models::Signature.find_or_create(:signature => 'triggers active', :plugin => name, :method => 'active', :group_id => admin.pk, :description => 'List all currently active triggers')
-        Models::Signature.find_or_create(:signature => 'triggers list', :plugin => name, :method => 'list', :group_id => admin.pk, :description => 'List all triggers and their current status')
-        Models::Signature.find_or_create(:signature => 'triggers add (\S+)', :plugin => name, :method => 'add', :group_id => admin.pk, :description => 'Add a new trigger and activate it').params = [:trigger]
-        Models::Signature.find_or_create(:signature => 'triggers remove (\d+)', :plugin => name, :method => 'remove', :group_id => admin.pk, :description => 'Remove trigger').params = [:id]
-        Models::Signature.find_or_create(:signature => 'triggers activate (\d+)', :plugin => name, :method => 'activate', :group_id => admin.pk, :description => 'Activate the trigger').params = [:id]
-        Models::Signature.find_or_create(:signature => 'triggers deactivate (\d+)', :plugin => name, :method => 'deactivate', :group_id => admin.pk, :description => 'Deactivate the trigger').params = [:id]
+        add_sig(:sig => 'triggers active', :method => :active, :group => admin, :desc => 'List all currently active triggers')
+        add_sig(:sig => 'triggers list', :method => :list, :group => admin, :desc => 'List all triggers and their current status')
+        add_sig(:sig => 'triggers add (\S+)', :method => :add, :group => admin, :desc => 'Add a new trigger and activate it', :params => [:trigger])
+        add_sig(:sig => 'triggers remove (\d+)', :method => :remove, :group => admin, :desc => 'Remove trigger', :params => [:id])
+        add_sig(:sig => 'triggers activate (\d+)', :method => :activate, :group => admin, :desc => 'Activate the trigger', :params => [:id])
+        add_sig(:sig => 'triggers deactivate (\d+)', :method => :deactivate, :group => admin, :desc => 'Deactivate the trigger', :params => [:id])
     end
 
     def active(message, params)
@@ -40,7 +40,7 @@ include Messages::Outgoing
     end
     
     def add(message, params)
-        Models::Trigger.find_or_create(:trigger => params[:trigger]).update_with_params(:active => true)
+        Models::Trigger.find_or_create(:trigger => params[:trigger]).update(:active => true)
         @pipeline << Privmsg.new(message.replyto, "Trigger #{params[:trigger]} is now active")
         @pipeline << Messages::Internal::TriggersUpdate.new
     end
@@ -60,7 +60,7 @@ include Messages::Outgoing
     def activate(message, params)
         trigger = Models::Trigger[params[:id]]
         if(trigger)
-            trigger.update_with_params(:active => true)
+            trigger.update(:active => true)
             @pipeline << Privmsg.new(message.replyto, "Trigger #{trigger.trigger} has been activated")
             @pipeline << Messages::Internal::TriggersUpdate.new
         else
@@ -71,7 +71,7 @@ include Messages::Outgoing
     def deactivate(message, params)
         trigger = Models::Trigger[params[:id]]
         if(trigger)
-            trigger.update_with_params(:active => false)
+            trigger.update(:active => false)
             @pipeline << Privmsg.new(message.replyto, "Trigger #{trigger.trigger} has been deactivated")
             @pipeline << Messages::Internal::TriggersUpdate.new
         else

data/lib/mod_spox/Bot.rb

@@ -4,17 +4,22 @@
  'mod_spox/PluginManager',
  'mod_spox/MessageFactory',
  'mod_spox/BaseConfig',
- 'mod_spox/Timer',
  'mod_spox/messages/Messages',
  'mod_spox/models/Models',
  'mod_spox/Helpers',
- 'mod_spox/Pool'].each{|f|require f}
+ 'mod_spox/Timer'].each{|f|require f}
+require 'actionpool'
+require 'actiontimer'
+
 module ModSpox
 
     class Bot
 
         # bot timer
         attr_reader :timer
+        
+        # thread pool
+        attr_reader :pool
 
         # message pipeline
         attr_reader :pipeline
@@ -30,15 +35,19 @@ module ModSpox
 
         # Create a Bot
         def initialize
-            Logger.initialize($LOGTO, $LOGLEVEL)
-            Pool.instance
+            unless(ModSpox.logto.nil?)
+                logger = ::Logger.new(ModSpox.logto, 'daily')
+                Logger.initialize(logger, ModSpox.loglevel)
+            end
             clean_models
+            @servers = Array.new
+            @channels = Array.new
             @start_time = Time.now
-            @pipeline = Pipeline.new
-            @timer = Timer.new(@pipeline)
-            @timer.start
+            @pool = ActionPool::Pool.new(10, 100, 60, nil, logger)
+            @pipeline = Pipeline.new(@pool)
+            @timer = Timer.new(ActionTimer::Timer.new(@pool, logger), @pipeline)
             @config = BaseConfig.new(BotConfig[:userconfigpath])
-            @factory = MessageFactory.new(@pipeline)
+            @factory = MessageFactory.new(@pipeline, @pool)
             @socket = nil
             @plugin_manager = PluginManager.new(@pipeline)
             if(@config[:plugin_upgrade] == 'yes')
@@ -60,10 +69,10 @@ module ModSpox
 
         # Run the bot
         def run
-            trap('SIGTERM'){ Logger.warn("Caught SIGTERM"); start_shutdown }
-            trap('SIGKILL'){ Logger.warn("Caught SIGKILL"); start_shutdown }
-            trap('SIGINT'){ Logger.warn("Caught SIGINT"); start_shutdown }
-            trap('SIGQUIT'){ Logger.warn("Caught SIGQUIT"); start_shutdown }
+            trap('SIGTERM'){ Logger.warn("Caught SIGTERM"); halt }
+            trap('SIGKILL'){ Logger.warn("Caught SIGKILL"); halt }
+            trap('SIGINT'){ Logger.warn("Caught SIGINT"); halt }
+            trap('SIGQUIT'){ Logger.warn("Caught SIGQUIT"); halt }
             until @shutdown do
                 @pipeline << Messages::Internal::BotInitialized.new
                 begin
@@ -106,10 +115,28 @@ module ModSpox
             begin
                 @socket = Sockets.new(self) if @socket.nil?
                 @socket.irc_connect(message.server, message.port)
-                @pipeline << Messages::Internal::Connected.new(message.server, message.port)
             rescue Object => boom
                 Logger.warn("Failed connection to server: #{boom}")
-                @pipeline << Messages::Internal::ConnectionFailed.new(message.server, message.port)
+                @pipeline << Messages::Internal::ConnectionFailed.new(@socket.irc_socket.server, @socket.irc_socket.port)
+            end
+        end
+
+        # message:: Messages::Internal::Reconnect
+        # instructs bot to reconnect to IRC server
+        def reconnect(message=nil)
+            begin
+                @plugin_manager.reload_plugins
+                @socket.irc_reconnect
+            rescue Object => boom
+                Logger.warn("Initial reconnect failed. (#{boom}) Starting timed reconnect process.")
+                begin
+                    @socket.irc_reconnect
+                rescue Object => boom
+                    Logger.warn("Failed to connect to server. Reason: #{boom}")
+                    Logger.warn("Will retry in 20 seconds")
+                    sleep(20)
+                    retry
+                end
             end
         end
 
@@ -123,6 +150,7 @@ module ModSpox
         def bot_stats
             return {:uptime => Helpers::format_seconds(Time.now - @start_time),
                     :plugins => @plugin_manager.plugins.size,
+                    :socket_connect => @socket.irc_socket.connected_at,
                     :sent => @socket.irc_socket.sent,
                     :received => @socket.irc_socket.received}
         end
@@ -154,7 +182,8 @@ module ModSpox
              :Internal_StatusRequest => :status, :Internal_ChangeNick => :set_nick,
              :Internal_NickRequest => :get_nick, :Internal_HaltBot => :halt,
              :Internal_Disconnected => :disconnected, :Internal_TimerClear => :clear_timer,
-             :Outgoing_Raw => :raw
+             :Outgoing_Raw => :raw, :Internal_Reconnect => :reconnect,
+             :Incoming_Join => :check_join, :Incoming_Part => :check_part
              }.each_pair{ |type,method| @pipeline.hook(self, method, type) }
         end
 
@@ -167,12 +196,11 @@ module ModSpox
         # message:: Messages::Internal::Disconnected
         # Disconnect the bot from the IRC server
         def disconnected(message)
-            @socket.shutdown
-            @socket = nil
+            reload
         end
 
         # Stop the bot
-        def halt(message)
+        def halt(message=nil)
             @shutdown = true
             reload
         end
@@ -282,6 +310,7 @@ module ModSpox
         # message:: Messages::Outgoing::Invite message
         # Sends INVITE message to server
         def invite(message)
+            okay_to_send(message.channel)
             nick = message.nick.is_a?(Models::Nick) ? message.nick.nick : message.nick
             channel = message.channel.is_a?(Models::Channel) ? message.channel.name : message.channel
             @socket << "INVITE #{nick} #{channel}"
@@ -290,6 +319,7 @@ module ModSpox
         # message:: Messages::Outgoing::Kick message
         # Sends KICK message to server
         def kick(message)
+            okay_to_send(message.channel)
             nick = message.nick.is_a?(Models::Nick) ? message.nick.nick : message.nick
             channel = message.channel.is_a?(Models::Channel) ? message.channel.name : message.channel
             @socket << "KICK #{channel} #{nick} :#{message.reason}"
@@ -298,18 +328,19 @@ module ModSpox
         # message:: Messages::Outgoing::Privmsg message
         # Sends PRIVMSG message to server
         def privmsg(message)
+            okay_to_send(message.target)
             target = message.target.name if message.target.is_a?(Models::Channel)
             target = message.target.nick if message.target.is_a?(Models::Nick)
             target = message.target unless target
             messages = message.message.is_a?(Array) ? message.message : [message.message]
             messages.each do |part|
                 part.split("\n").each do |content|
-                    while(content.size > 450)
-                        output = content[0..450]
-                        content.slice!(0, 451) #(450, content.size)
-                        @socket << "PRIVMSG #{target} :#{message.is_ctcp? ? "\cA#{message.ctcp_type} #{output}\cA" : output}"
+                    while(content.size > 400)
+                        output = content[0..400]
+                        content.slice!(0, 401) #(450, content.size)
+                        @socket.prioritize_message(target, "PRIVMSG #{target} :#{message.is_ctcp? ? "\cA#{message.ctcp_type} #{output}\cA" : output}")
                     end
-                    @socket << "PRIVMSG #{target} :#{message.is_ctcp? ? "\cA#{message.ctcp_type} #{content}\cA" : content}"
+                    @socket.prioritize_message(target, "PRIVMSG #{target} :#{message.is_ctcp? ? "\cA#{message.ctcp_type} #{content}\cA" : content}")
                 end
             end
         end
@@ -317,6 +348,7 @@ module ModSpox
         # message:: Messages::Outgoing::Notice message
         # Sends NOTICE message to server
         def notice(message)
+            okay_to_send(message.target)
             target = message.target.name if message.target.is_a?(Models::Channel)
             target = message.target.nick if message.target.is_a?(Models::Nick)
             @socket << "NOTICE #{target} :#{message}"
@@ -399,14 +431,14 @@ module ModSpox
         # Sends WHO message to server
         def who(message)
             o = message.only_ops? ? 'o' : ''
-            @socket << "WHO #{message.mask} #{o}"
+            @socket.prioritize_message('*who', "WHO #{message.mask} #{o}")
         end
 
         # message:: Messages::Outgoing::Whois message
         # Sends WHOIS message to server
         def whois(message)
             nick = message.nick.is_a?(Models::Nick) ? message.nick.nick : message.nick
-            @socket << "WHOIS #{message.target_server} #{nick}"
+            @socket.prioritize_message('*whois', "WHOIS #{message.target_server} #{nick}")
         end
 
         # message:: Messages::Outgoing::WhoWas message
@@ -502,22 +534,66 @@ module ModSpox
             @socket << message.message
         end
 
+        def check_join(m)
+            if(m.nick.botnick)
+                @channels << m.channel.name.downcase
+            end
+        end
+
+        def check_part(m)
+            if(m.nick.botnick)
+                @channels.delete(m.channel.name.downcase)
+            end
+        end
+
         private
 
-        def start_shutdown
-            @shutdown = true
-            @lock.synchronize do
-                @waiter.signal
+        # channel:: channel to check
+        # checks if the bot is parked in the given channel
+        # and raises an exception (and logs) if the bot
+        # is not in the given channel
+        def okay_to_send(channel)
+            if(channel.is_a?(String) && ['&', '#', '+', '!'].include?(channel[0]))
+                channel = Helpers.find_model(channel)
             end
+            return unless channel.is_a?(Models::Channel)
+            if(channel.quiet)
+                Logger.error("Attempted to send to channel where bot is not allowed to speak: #{channel.name}")
+                raise Exceptions::QuietChannel.new(channel)
+            end
+            unless(in_channel?(channel))
+                Logger.error("Attempted to send to channel where bot is not parked: #{channel.name}.")
+                raise Exceptions::NotInChannel.new(channel)
+            end
+        end
+
+        def in_channel?(channel)
+            unless(@channels.include?(channel.name.downcase))
+                repopulate_channels
+                return @channels.include?(channel.name.downcase)
+            else
+                return true
+            end
+        end
+
+        def repopulate_channels
+            bot = Models::Nick.filter(:botnick => true).first
+            raise Exceptions::BotException.new("I DON'T KNOW WHO I AM") unless bot
+            @channels.clear
+            bot.channels.each{|c| @channels << c.name.downcase}
         end
 
         # Cleans information from models to avoid
         # stale values
         def clean_models
-            Models::Nick.clean
-            Models::Channel.clean
-            Models::NickChannel.destroy_all
-            Models::Signature.delete_all
+            Models::NickMode.destroy
+            Models::Channel.update(:topic => nil)
+            Models::Nick.update(:username => nil, :real_name => nil, :address => nil,
+                :source => nil, :connected_at => nil, :connected_to => nil,
+                :seconds_idle => nil, :away => false, :visible => false, :botnick => false)
+            Models::Auth.update(:authed => false)
+            Database.db[:auth_masks_nicks].delete
+            Database.db[:nick_channels].delete
         end
     end