spox-mod_spox 0.3.1

data/data/mod_spox/plugins/Joiner.rb

@@ -0,0 +1,23 @@
+require 'mod_spox/messages/outgoing/Join'
+require 'mod_spox/messages/outgoing/Who'
+
+class Joiner < ModSpox::Plugin
+    def initialize(pipeline)
+        super(pipeline)
+        admin = Models::Group.filter(:name => 'admin').first
+        add_sig(:sig => 'join (\S+)', :method => :join, :group => admin, :params => [:channel])
+        @pipeline.hook(self, :send_who, :Incoming_Join)
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # Join the given channel
+    def join(message, params)
+        @pipeline << Messages::Outgoing::Join.new(params[:channel])
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Join
+    # Send a WHO request for channel on join
+    def send_who(message)
+        @pipeline << ModSpox::Messages::Outgoing::Who.new(message.channel.name) if message.nick == me
+    end
+end

data/data/mod_spox/plugins/Nicker.rb

@@ -0,0 +1,14 @@
+require 'mod_spox/messages/outgoing/Nick'
+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

@@ -0,0 +1,23 @@
+require 'mod_spox/messages/outgoing/Part'
+class Parter < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super(pipeline)
+        admin = Models::Group.filter(:name => 'admin').first
+        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
+    # Bot will part from given channel
+    def part(message, params)
+        @pipeline << Messages::Outgoing::Part.new(params[:channel])
+    end
+    
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # Bot will part from channel command is issued within
+    def direct_part(message, params)
+        @pipeline << Messages::Outgoing::Part.new(message.target)
+    end
+
+end

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

@@ -0,0 +1,180 @@
+['mod_spox/messages/outgoing/Privmsg',
+ 'mod_spox/messages/internal/PluginLoadRequest',
+ 'mod_spox/messages/internal/PluginUnloadRequest',
+ 'mod_spox/messages/internal/PluginReload',
+ 'mod_spox/messages/internal/PluginModuleRequest'].each{|f|require f}
+class PluginLoader < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super(pipeline)
+        admin = Models::Group.filter(:name => 'admin').first
+        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
+
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: matching signature params
+    # Output currently available plugins for loading
+    def available_plugins(message, params)
+        output = ["\2Currently available plugins:\2"]
+        find_plugins.each_pair do | plugin, path |
+            output << "\2#{plugin}:\2 #{path}"
+        end
+        reply message.replyto, output
+    end
+
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: matching signature params
+    # Output currently loaded plugins
+    def loaded_plugins(message, params)
+        @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "\2Currently loaded plugins:\2 #{plugin_list.join(', ')}")
+    end
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: matching signature params
+    # Load the given plugin
+    def load_plugin(message, params)
+        plugins = find_plugins
+        if(plugins.has_key?(params[:plugin].to_sym))
+            name = plugin_discovery(BotConfig[:pluginextraspath]).keys.include?(params[:plugin].to_sym) ? nil : "#{params[:plugin]}.rb"
+            @pipeline << Messages::Internal::PluginLoadRequest.new(self, plugins[params[:plugin].to_sym], name)
+            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Okay")
+        else
+            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Failed to find plugin: #{params[:plugin]}")
+        end
+    end
+
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: matching signature params
+    # Unload the given plugin
+    def unload_plugin(message, params)
+        path = loaded_path(params[:plugin].to_sym)
+        unless(path.nil?)
+            name = plugin_discovery(BotConfig[:pluginextraspath]).keys.include?(params[:plugin].to_sym) ? nil : ".#{params[:plugin]}.rb"
+            @pipeline << Messages::Internal::PluginUnloadRequest.new(self, path, name)
+            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Okay")
+        else
+            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, "Failed to find loaded plugin named: #{params[:plugin]}")
+        end
+    end
+
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # params:: matching signature params
+    # Reloads plugins
+    def reload_plugin(message, params)
+        if(params[:plugin])
+            users = plugin_discovery(BotConfig[:userpluginpath])
+            extras = plugin_discovery(BotConfig[:pluginextraspath])
+            fresh = nil
+            stale = nil
+            users.each_pair{|name, path| stale = path if name == params[:plugin]}
+            extras.each_pair{|name, path| fresh = path if name == params[:plugin]}
+            if(fresh && stale)
+                @pipeline << Messages::Internal::PluginReload.new(fresh, stale)
+                reply message.replyto, "Reloading #{params[:plugin]}"
+            else
+                reply message.replyto, "\2Error:\2 Failed to find new and stale versions of: #{params[:plugin]}"
+            end
+        else
+            @pipeline << Messages::Internal::PluginReload.new
+            @pipeline << Messages::Outgoing::Privmsg.new(message.replyto, 'Full plugin reload requested')
+        end
+    end
+
+    # message:: ModSpox::Messages::Internal::PluginModuleResponse
+    # Receives the plugins module
+    def get_module(message)
+        @plugins_mod = message.module
+    end
+
+    # Upgrades extra plugins to latest version
+    def extras_upgrade
+        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)}
+        extras.keys.each do |plugin|
+            path = loaded_path(plugin)
+            @pipeline << Messages::Internal::PluginUnloadRequest.new(self, path, plugin)
+        end
+        Logger.info('Waiting for plugins to complete unloading...')
+        sleep(3)
+        Logger.info('Loading active plugins back into the bot')
+        extras.each do |name, path|
+            @pipeline << Messages::Internal::PluginLoadRequest.new(self, path)
+        end
+        Logger.info("Plugin upgrade is now complete. Upgraded to version: #{ModSpox.botversion}")
+    end
+
+    private
+
+    # Returns the list of currently loaded plugins
+    def plugin_list
+        plug = []
+        @pipeline << Messages::Internal::PluginModuleRequest.new(self)
+        sleep(0.01) while @plugins_mod.nil?
+        @plugins_mod.constants.sort.each do |const|
+            klass = @plugins_mod.const_get(const)
+            if(klass < Plugin)
+                plug << const
+            end
+        end
+        @plugins_mod = nil
+        return plug
+    end
+
+    # Finds available plugins for loading
+    def find_plugins
+        users = plugin_discovery(BotConfig[:userpluginpath])
+        extras = plugin_discovery(BotConfig[:pluginextraspath])
+        plugins = users.merge(extras)
+        plugin_list.each do |name|
+            plugins.delete(name) if plugins.has_key?(name)
+        end
+        return plugins
+    end
+
+    # path:: path to directory
+    # Discovers any plugins within the files in the given path
+    def plugin_discovery(path)
+        plugins = Hash.new
+        Dir.new(path).each do |file|
+            begin
+                next unless file =~ /\.rb$/
+                sandbox = Module.new
+                sandbox.module_eval(IO.readlines("#{path}/#{file}").join("\n"))
+                sandbox.constants.each do |const|
+                    klass = sandbox.const_get(const)
+                    plugins[const.to_sym] = "#{path}/#{file}" if klass < Plugin
+                end
+            rescue Object => boom
+                Logger.warn("Failed to parse file: #{path}/#{file}. Reason: #{boom}\n#{boom.backtrace.join("\n")}")
+                next
+            end
+        end
+        return plugins
+    end
+
+    # name:: plugin name
+    # Returns the file path the given plugin originated from
+    def loaded_path(name)
+        Dir.new(BotConfig[:userpluginpath]).each do |file|
+            begin
+                next unless file =~ /\.rb$/
+                sandbox = Module.new
+                sandbox.module_eval(IO.readlines("#{BotConfig[:userpluginpath]}/#{file}").join("\n"))
+                sandbox.constants.each do |const|
+                    return "#{BotConfig[:userpluginpath]}/#{file}" if const == name
+                end
+            rescue Object => boom
+                Logger.warn("Failed to load file: #{file}. Reason: #{boom}")
+            end
+        end
+        return nil
+    end
+
+end

data/data/mod_spox/plugins/Ponger.rb

@@ -0,0 +1,70 @@
+require 'mod_spox/messages/outgoing/Pong'
+require 'mod_spox/messages/outgoing/Ping'
+require 'mod_spox/messages/internal/Reconnect'
+require 'mod_spox/messages/internal/TimerAdd'
+
+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
+    # Sends responding pongs to server pings
+    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/PoolConfig.rb

@@ -0,0 +1,52 @@
+class PoolConfig < ModSpox::Plugin
+
+    def initialize(args)
+        super
+        group = Group.find_or_create(:name => 'admin')
+        add_sig(:sig => 'pool max workers(\s(\d+))?', :method => :max_workers, :group => group,
+                :desc => 'Show/set max number of worker threads', :params => [:max])
+        add_sig(:sig => 'pool worker timeout(\s(\d+))?', :method => :max_timeout, :group => group,
+                :desc => 'Show/set max worker timeout', :params => [:max])
+        add_sig(:sig => 'pool workers total', :method => :workers_total, :group => group,
+                :desc => 'Show current number of workers in pool')
+    end
+
+    def max_workers(message, params)
+        if(params[:max].nil?)
+            reply message.replyto, "Maximum number of worker threads allowed in pool: #{Pool.workers_max}"
+        else
+            params[:max] = params[:max].strip.to_i
+            if(params[:max] > 0)
+                config = Config.find_or_create(:name => 'pool_workers_min')
+                config.value = params[:max]
+                config.save
+                Pool.workers_max = params[:max]
+                reply message.replyto, "\2Thread Pool Update:\2 Number of worker threads updated to: #{params[:max]}"
+            else
+                reply message.replyto, "\2Error:\2 You must have at least one worker thread"
+            end
+        end
+    end
+
+    def max_timeout(message, params)
+        if(params[:max].nil?)
+            reply message.replyto, "Maximum number of seconds threads allowed per task: #{Pool.worker_timeout == 0 ? 'no limit' : Pool.worker_timeout}"
+        else
+            params[:max] = params[:max].strip.to_i
+            if(params[:max] >= 0)
+                config = Config.find_or_create(:name => 'pool_timeout')
+                config.value = params[:max]
+                config.save
+                Pool.worker_timeout = params[:max]
+                reply message.replyto, "\2Thread Pool Update:\2 Worker processing timeout updated to: #{params[:max]} seconds"
+            else
+                reply message.replyto, "\2Error:\2 Threads are not able to finish executing before they start"
+            end
+        end
+    end
+
+    def workers_total(message, params)
+        reply message.replyto, "Current number of worker threads in pool: #{Pool.workers}"
+    end
+
+end

data/data/mod_spox/plugins/Quitter.rb

@@ -0,0 +1,15 @@
+require 'mod_spox/messages/internal/HaltBot'
+
+class Quitter < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super(pipeline)
+        add_sig(:sig => 'quit(\s.+)?', :method => :quit, :group => Models::Group.filter(:name => 'admin').first, :params => [:channel, :message])
+    end
+
+    # message:: ModSpox::Messages::Incoming::Privmsg
+    # Instructs the bot to shutdown    
+    def quit(message, params)
+        @pipeline << Messages::Internal::HaltBot.new
+    end
+end

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

@@ -0,0 +1,31 @@
+require 'mod_spox/messages/internal/StatusRequest'
+
+class Status < ModSpox::Plugin
+
+    def initialize(pipeline)
+        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
+    
+    def status(m, pa)
+        @resp << m.replyto
+        @pipeline << Messages::Internal::StatusRequest.new(self)
+    end
+    
+    def version(message, params)
+        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 \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
+
+end

data/data/mod_spox/plugins/Triggers.rb

@@ -0,0 +1,85 @@
+require 'mod_spox/messages/internal/TriggersUpdate'
+require 'mod_spox/messages/outgoing/Privmsg'
+
+class Triggers < ModSpox::Plugin
+
+include Messages::Outgoing
+
+    def initialize(pipeline)
+        super(pipeline)
+        admin = Models::Group.filter(:name => 'admin').first
+        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)
+        triggers = Models::Trigger.filter(:active => true)
+        if(triggers)
+            output = ["\2Currently active triggers:\2"]
+            triggers.each do |t|
+                output << "#{t.pk}: #{t.trigger}"
+            end
+            reply message.replyto, output
+        else
+            @pipeline << Privmsg.new(message.replyto, 'No triggers are currently active')
+        end
+    end
+    
+    def list(message, params)
+        triggers = Models::Trigger.all
+        if(triggers)
+            output = ["\2Trigger listing:\2"]
+            triggers.each do |t|
+                output << "#{t.pk}: #{t.trigger}  ->  \2#{t.active ? "activated" : "not activated"}\2"
+            end
+            reply message.replyto, output
+        else
+            @pipeline << Privmsg.new(message.replyto, 'No triggers found')
+        end
+    end
+    
+    def add(message, params)
+        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
+    
+    def remove(message, params)
+        trigger = Models::Trigger[params[:id]]
+        if(trigger)
+            trig = trigger.trigger
+            trigger.destroy
+            @pipeline << Privmsg.new(message.replyto, "Trigger #{trig} has been removed")
+            @pipeline << Messages::Internal::TriggersUpdate.new
+        else
+            @pipeline << Privmsg.new(message.replyto, "Failed to find trigger with ID: #{params[:id]}")
+        end
+    end
+    
+    def activate(message, params)
+        trigger = Models::Trigger[params[:id]]
+        if(trigger)
+            trigger.update(:active => true)
+            @pipeline << Privmsg.new(message.replyto, "Trigger #{trigger.trigger} has been activated")
+            @pipeline << Messages::Internal::TriggersUpdate.new
+        else
+            @pipeline << Privmsg.new(message.replyto, "Failed to find trigger with ID: #{params[:id]}")
+        end
+    end
+    
+    def deactivate(message, params)
+        trigger = Models::Trigger[params[:id]]
+        if(trigger)
+            trigger.update(:active => false)
+            @pipeline << Privmsg.new(message.replyto, "Trigger #{trigger.trigger} has been deactivated")
+            @pipeline << Messages::Internal::TriggersUpdate.new
+        else
+            @pipeline << Privmsg.new(message.replyto, "Failed to find trigger with ID: #{params[:id]}")
+        end
+    end
+
+end

data/lib/mod_spox/BaseConfig.rb

@@ -0,0 +1,51 @@
+require 'mod_spox/Exceptions'
+
+module ModSpox
+
+    class BaseConfig
+    
+        # file_path:: path to configuration file
+        # Creates new BaseConfig
+        def initialize(file_path)
+            @config = Hash.new
+            @file_path = file_path
+            parse_configuration
+        end
+        
+        # name:: key of config item wanted
+        # Provides access to configuration data
+        def [](name)
+            name = name.to_sym unless name.is_a?(Symbol)
+            raise Exceptions::UnknownKey.new("Configuration has no value named: #{name.to_s}") unless @config.has_key?(name)
+            return @config[name]
+        end
+        
+        def []=(key, value)
+            key = key.to_sym unless key.is_a?(Symbol)
+            @config[key] = value
+            write_configuration
+        end
+        
+        # Parses the configuration file into a usable Hash
+        def parse_configuration
+            return unless File.exists?(BotConfig[:userconfigpath])
+            IO.readlines(BotConfig[:userconfigpath]).each{|line|
+                if(line =~ /^(\S+)\s*=\s*(\S*)\s*$/)
+                    @config[$1.to_sym] = $2
+                end
+            }
+        end
+        
+        # Writes the configuration file out to the provided file_path
+        # during initialization
+        def write_configuration
+            file = File.open(BotConfig[:userconfigpath], 'w')
+            @config.each_pair{|k,v|
+                file.puts("#{k.to_s}=#{v}")
+            }
+            file.close
+        end
+    
+    end
+
+end