mod_spox 0.0.2 → 0.0.3

data/data/mod_spox/plugins/Helper.rb

@@ -0,0 +1,37 @@
+class Helper < ModSpox::Plugin
+
+    include Models
+
+    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]
+    end
+    
+    def default_help(message, params)
+        plugins = Signature.map(:plugin)
+        plugins.uniq!
+        reply message.replyto, "Plugins currently available for help: #{plugins.join(', ')}"
+        reply message.replyto, "Request help on a plugin: !help Plugin"
+    end
+    
+    def plugin_help(message, params)
+        sigs = Signature.filter(:plugin => params[:plugin])
+        if(sigs.count > 0)
+            reply message.source, "Available triggers for plugin: \2#{params[:plugin]}\2"
+            sigs.each do |sig|
+                output = []
+                output << "\2Pattern:\2 #{sig.signature}"
+                output << "\2Parameters:\2 [#{sig.params.join(' | ')}]" if sig.params
+                output << "\2Auth Group:\2 #{Group[sig.group_id].name}" if sig.group_id
+                output << "\2Description:\2 #{sig.description}" if sig.description
+                reply message.source, output.join(' ')
+            end
+        else
+            reply message.replyto, "\2Error:\2 No triggers found for plugin named: #{params[:plugin]}"
+        end
+    end
+
+end

data/lib/mod_spox/Bot.rb

@@ -272,7 +272,7 @@ module ModSpox
             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
-            @socket << "PRIVMSG #{target} :#{message.message}"
+            @socket << "PRIVMSG #{target} :#{message.is_action? ? "\cAACTION #{message.message}\cA" : message.message}"
         end
 
         # message:: Messages::Outgoing::Notice message

data/lib/mod_spox/ConfigurationWizard.rb

@@ -1,4 +1,4 @@
-['etc', 'termios', 'mod_spox/Loader',
+['etc', 'mod_spox/Loader',
  'mod_spox/BotConfig',  'mod_spox/BaseConfig'].each{|f|require f}
 
 
@@ -28,6 +28,12 @@ module ModSpox
             @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}            
+            @stuck_visible = true
+            begin
+                require 'termios'
+                @stuck_visible = false
+            rescue Object => boom
+            end
         end
     
         # Run the configuration wizard
@@ -83,7 +89,7 @@ module ModSpox
         # echo:: echo user input
         # Turns echoing of user input on or off
         def input_echo(echo=true)
-            return if echo == @echo
+            return if echo == @echo || @stuck_visible
             term = Termios::getattr($stdin)
             term.c_lflag |= Termios::ECHO if echo
             term.c_lflag &= ~Termios::ECHO unless echo
@@ -137,11 +143,12 @@ module ModSpox
                     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 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 text, 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 TYPE sig_requirement AS ENUM ('public', 'private', 'both')"
                     Database.db << "CREATE TABLE nicks (id serial not null primary key, nick text unique not null, username text, real_name text, address text, source text, connected_at timestamp, connected_to text, seconds_idle integer, visible boolean not null default false, away boolean not null default false, botnick boolean not null default false)"
                     Database.db << "CREATE TABLE channels (id serial not null primary key, name text unique not null, password text, autojoin boolean not null default false, topic text, quiet boolean not null default false, parked boolean not null default false)"
                     Database.db << "CREATE TABLE auths (id serial not null primary key, password text, services boolean not null default false, mask text unique, authed boolean not null default false, nick_id integer unique references nicks)"
@@ -151,7 +158,7 @@ module ModSpox
                     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 text 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 text 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 text not null, params text, group_id integer default null references groups, method text not null, plugin text not null, description text)"
+                    Database.db << "CREATE TABLE signatures (id serial not null primary key, signature text not null, params text, group_id integer default null references groups, method text not null, plugin text not null, description text, requirement sig_requirement default 'both' not null)"
                     Database.db << "CREATE TABLE settings (id serial not null primary key, name text unique not null, value text)"
                     Database.db << "CREATE TABLE triggers (id serial not null primary key, trigger text 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))"
@@ -167,7 +174,7 @@ module ModSpox
                     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 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 text, requirement text 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)"

data/lib/mod_spox/MessageFactory.rb

@@ -5,10 +5,9 @@ module ModSpox
         # pipeline:: Message pipeline
         # Create a new MessageFactory
         def initialize(pipeline)
-            super(1)
+            super()
             @pipeline = pipeline
             @handlers = Hash.new
-            @queue = Queue.new
             Logger.log("Created new factory queue: #{@queue}", 15)
             build_handlers
             start_pool

data/lib/mod_spox/Monitors.rb

@@ -34,24 +34,42 @@ module ModSpox
         
             # Create a new Boolean Monitor
             def initialize
-                @thread = nil
+                @threads = []
             end
             
             # Stop waiting
             def wakeup
-                Logger.log("Sending wakeup for thread: #{@thread}", 5)
-                @thread.run unless @thread == nil
-                Logger.log("Status of thread to wakeup: #{@thread.status}", 5)
-                Logger.log("Calling thread is: #{Thread.current}", 5)
-                @thread = nil
+                return if @threads.empty?
+                @threads.each do |thread|
+                    if(thread.status == 'sleep')
+                        Logger.log("Sending wakeup for thread: #{thread}", 5)
+                        thread.run
+                        Logger.log("Status of thread to wakeup: #{thread.status}", 5)
+                        Logger.log("Calling thread is: #{Thread.current}", 5)
+                    else
+                        Logger.log("Thread to wakeup has been killed: #{thread}")
+                    end
+                    @threads.delete(thread)
+                end
             end
             
             # Start waiting
             def wait
-                @thread = Thread.current
-                Logger.log("Stopping execution of thread: #{@thread}", 5)
+                @threads << Thread.current
+                Logger.log("Stopping execution of thread: #{Thread.current}", 5)
                 Thread.stop
             end
+            
+            # Returns if a thread is currently waiting in this monitor
+            def thread_waiting?(thread)
+                return @threads.include?(thread)
+            end
+            
+            # Removes a thread from the list of waiting. Will be removed automatically
+            # if thread has been killed on next call to wakeup
+            def remove_thread(thread)
+                @threads.delete(thread) if @threads.include?(thread)
+            end
         
         end
     end

data/lib/mod_spox/Pipeline.rb

@@ -1,14 +1,12 @@
 module ModSpox
 
     class Pipeline < Pool
-    
-        # procs:: number of threads running in Pool
+
         # Create a new Pipeline
-        def initialize(procs=3)
-            super(procs)
+        def initialize
+            super()
             @timeout = 20 # Anything over 20 seconds and we assume a plugin locked up the thread
-            @messageq = Queue.new
-            Logger.log("Created queue #{@messageq} in pipeline", 10)
+            Logger.log("Created queue #{@queue} in pipeline", 10)
             @hooks = Hash.new
             @plugins = Hash.new
             @admin = Models::Group.filter(:name => 'admin').first
@@ -23,7 +21,7 @@ module ModSpox
         # Queues a message to send down pipeline
         def <<(message)
             Logger.log("Message added to pipeline queue: #{message}", 5)
-            @messageq << message
+            @queue << message
         end
         
         # plugin:: Plugin to hook to pipeline
@@ -65,9 +63,9 @@ module ModSpox
         def unhook(object, method, type)
             Logger.log("Object #{object.class.to_s} unhooking from messages of type: #{type}", 10)
             type = type.gsub(/::/, '_').to_sym unless type.is_a?(Symbol)
-            name = object.class.gsub(/^.+:/, '').to_sym
-            raise Exception::InvalidValue.new("Unknown hook type given: #{type.to_s}") unless @hooks.has_key?(type)
-            raise Exception::InvalidValue.new("Unknown object hooked: #{name.to_s}") unless @hooks[type].has_key?(name)
+            name = object.class.to_s.gsub(/^.+:/, '').to_sym
+            raise Exceptions::InvalidValue.new("Unknown hook type given: #{type.to_s}") unless @hooks.has_key?(type)
+            raise Exceptions::InvalidValue.new("Unknown object hooked: #{name.to_s}") unless @hooks[type].has_key?(name)
             @hooks[type][name].each{|hook|
                 @hooks[type][name].delete(hook) if hook[:method] == method
             }
@@ -98,8 +96,8 @@ module ModSpox
         
         # Processes messages
         def processor
+            message = @queue.pop
             begin
-                message = @messageq.pop
                 Logger.log("Pipeline is processing a message: #{message}", 10)
                 parse(message)
                 type = message.class.to_s.gsub(/^ModSpox::Messages::/, '').gsub(/::/, '_').to_sym
@@ -140,10 +138,12 @@ module ModSpox
                     res = message.message.scan(/^#{trigger}#{sig.signature}$/)
                     if(res.size > 0)
                         next unless message.source.auth_groups.include?(sig.group) || message.source.auth_groups.include?(@admin) ||sig.group.nil?
+                        next if sig.requirement == 'private' && message.is_public?
+                        next if sig.requirement == 'public' && message.is_private?
                         params = Hash.new
                         sig.params.size.times do |i|
-                            params[sig.params[i - 1].to_sym] = res[0][i]
-                            Logger.log("Signature params: #{sig.params[i - 1].to_sym} = #{res[0][i]}")
+                            params[sig.params[i].to_sym] = res[0][i]
+                            Logger.log("Signature params: #{sig.params[i].to_sym} = #{res[0][i]}")
                         end
                         if(@plugins.has_key?(sig.plugin.to_sym))
                             begin

data/lib/mod_spox/PluginManager.rb

@@ -14,6 +14,7 @@ module ModSpox
             @pipeline.hook(self, :unload_plugin, :Internal_PluginUnloadRequest)
             @pipeline.hook(self, :reload_plugins, :Internal_PluginReload)
             @pipeline.hook(self, :send_modules, :Internal_PluginModuleRequest)
+            @pipeline.hook(self, :plugin_request, :Internal_PluginRequest)
             @plugins_module = Module.new
             load_plugins
         end
@@ -34,7 +35,6 @@ module ModSpox
         # Loads a plugin
         def load_plugin(message)
             begin
-                Logger.log("THE MESSAGE NAME IS: #{message.name}")
                 path = !message.name ? BotConfig[:userpluginpath] : "#{BotConfig[:userpluginpath]}/#{message.name}"
                 FileUtils.copy(message.path, path)
                 reload_plugins
@@ -69,6 +69,17 @@ module ModSpox
             @pipeline << Messages::Internal::PluginModuleResponse.new(message.requester, @plugins_module)
         end
         
+        # message:: Messages::Internal::PluginRequest
+        # Returns a plugin to requesting object
+        def plugin_request(message)
+            if(@plugins.has_key?(message.plugin))
+                response = Messages::Internal::PluginResponse.new(message.requester, @plugins[message.plugin])
+            else
+                response = Messages::Internal::PluginResponse.new(message.requester, nil)
+            end
+            @pipeline << response
+        end
+        
         private
         
         # Loads and initializes plugins

data/lib/mod_spox/Pool.rb

@@ -1,49 +1,232 @@
 module ModSpox
 
-    # The Pool class is used to reduce thread creation. When
-    # used in conjuntion with a PoolQueue, it provides an easy
-    # way to process many objects in an asynchronous manner
+    # The Pool class is used to reduce thread creation. It provides
+    # an easy way to process many objects in an asynchronous manner.
     class Pool
     
-        # num_procs:: Number of threads to use
+        # 
+        def Pool.max_threads(num=nil)
+            if(num.nil?)
+                return @@max_threads
+            else
+                num = num.to_i
+                raise Exceptions::InvalidValue.new('Maximum threads setting must be a positive integer') if num < 1
+                @@max_threads = num
+            end
+        end
+        
+        def Pool.max_thread_life(num=nil)
+            if(num.nil?)
+                return @@max_thread_life
+            else
+                num = num.to_i
+                raise Exceptions::InvalidValue.new('Maximum thread life setting must be a positive integer') if num < 1
+                @@max_thread_life = num
+            end
+        end
+
+        # Action thread is to perform
+        attr_reader :proc
+        # Storage space that the pool will be processing
+        attr_reader :queue
+        
         # Create a new Pool
-        def initialize(num_procs=2)
-            @num_threads = num_procs
-            @threads = Array.new
-            @kill = false
+        def initialize
+            @proc = Proc.new{ run_processor }
+            @queue = PoolQueue.new
         end
         
-        # Stop all the running threads
+        # Destroys this pool
         def destroy
-            @kill = true
-            @threads.each{|t|
-                Logger.log("Shutting down thread: #{t} in #{self.class.to_s}", 10)
-                t.exit
-            }
-            sleep(0.1)
+            Pool.remove_pool(self)
         end
         
         # Starts the pool
         def start_pool
-            @num_threads.times do
-                @threads << Thread.new{
-                    until @kill do
-                        processor
-                    end
-                }
-            end
+            Pool.add_pool(self)
         end
         
-        # Method the pool uses to do stuff.
-        # (It is important to note that using this can
-        # very easily eat up all your CPU time. The Processor
-        # method must yield at some point, otherwise it will
-        # just continue to loop, even if it is doing nothing.
-        # This is the reason for the PoolQueue as this Pool
-        # was created as a way to quickly process messages)
+        private 
+        
+        def run_processor
+            begin
+                processor
+            rescue Object => boom
+                Logger.log("Pool encountered an error processing code block: #{boom}")
+            end
+        end
+
         def processor
             raise Exceptions::NotImplemented.new('Processor method has not been implemented')
         end
+        
+        # Running pools
+        @@pools = Array.new
+        # Threads running in pool
+        @@threads = Hash.new
+        # Lock for thread safety
+        @@lock = Mutex.new
+        # Maximum number of threads in pool
+        @@max_threads = 10
+        # Maximum number of seconds a thread may spend waiting for an action
+        @@max_thread_life = 60
+        # Thread to tend to pool actions
+        @@pool_thread = nil
+        # Informs threads to halt
+        @@kill = false
+        # Place for threads to wait for actions
+        @@thread_stopper = Monitors::Boolean.new
+        # Timer for the Pool thread
+        @@watcher_timer = Monitors::Timer.new
+        
+        # Adds a new thread to the pool
+        def Pool.add_thread
+            if(@@threads.size < @@max_threads)
+                thread = Thread.new do
+                    sleep(0.01)
+                    until(@@kill) do
+                        Pool.schedule_thread
+                    end
+                end
+                @@threads[thread] = Time.now
+                Logger.log("New thread added to pool: #{thread}")
+            else
+                raise Exceptions::BotException.new("Reached maximum thread pool size: #{@@max_threads} threads")
+            end
+        end
+        
+        # thread:: Thread to delete
+        # Removes thread from pool
+        def Pool.delete_thread(thread)
+            @@lock.synchronize do
+                @@threads.delete(thread) if @@threads.has_key?(thread)
+                @@thread_stopper.remove_thread(thread)
+                thread.kill
+                Logger.log("Thread removed from thread pool: #{thread}")
+            end
+        end
+        
+        # Returns the largest queue size of all available pools
+        def Pool.max_queue_size
+            size = 0
+            @@pools.each do |pool|
+                size = pool.queue.size if pool.queue.size > size
+            end
+            return size
+        end
+        
+        # Schedules a thread within the pool
+        def Pool.schedule_thread
+            run_pool = nil
+            @@lock.synchronize do
+                @@pools.each do |pool|
+                    run_pool = pool if (run_pool.nil? && pool.queue.size > 0) || (!run_pool.nil? && (run_pool.queue.size < pool.queue.size))
+                end
+            end
+            unless(run_pool.nil?)
+                @@threads[Thread.current] = Time.now
+                run_pool.proc.call
+                @@threads[Thread.current] = Time.now
+            else
+                @@thread_stopper.wait
+            end
+        end
+        
+        # Starts the master thread for Pool maintanence
+        def Pool.start_watcher
+            @@pool_thread = Thread.new{
+                until(@@kill) do
+                    sleep_time = 0
+                    begin
+                        waiters = Pool.waiting_threads
+                        unless(waiters.empty?)
+                            waiters.each do |thread|
+                                time = Time.now.to_i - @@threads[thread].to_i
+                                sleep_time = (@@max_thread_life - time).to_i if sleep_time = 0 || (@@max_thread_life - time).to_i < sleep_time
+                                if(time > @@max_thread_life)
+                                    Pool.delete_thread(thread)
+                                elsif(!['sleep', 'run'].include?(thread.status))
+                                    Pool.delete_thread(thread)
+                                end
+                            end
+                        else
+                            if(Pool.max_queue_size > 0)
+                                Pool.add_thread
+                            end
+                        end
+                    rescue Object => boom
+                        Logger.log("Pool watcher caught an error (ignoring): #{boom}")
+                    end
+                    sleep_time = 1 if sleep_time == 0
+                    sleep_time = nil if sleep_time < 0
+                    Logger.log("Pool watcher thread is now sleeping for: #{sleep_time.nil? ? 'forever' : "#{sleep_time} seconds"}")
+                    @@watcher_timer.wait(sleep_time)
+                end
+            } if @@pool_thread.nil?
+        end
+        
+        # Forces sleeping threads to wake up
+        def Pool.wakeup_threads
+            @@watcher_timer.wakeup
+            @@thread_stopper.wakeup
+        end
+        
+        # Returns list of threads currently waiting for an action to process
+        def Pool.waiting_threads
+            waiting = []
+            @@threads.each_pair do |thread,time|
+                waiting << thread if @@thread_stopper.thread_waiting?(thread)
+            end
+            return waiting
+        end
+        
+        # Adds a Pool to the master Pool list        
+        def Pool.add_pool(pool)
+            @@pools << pool
+            @@lock.synchronize do
+                Pool.start_watcher
+            end
+        end
+        
+        # Removes a Pool from the master Pool list
+        def Pool.remove_pool(pool)
+            @@pools.delete(pool)
+            @@kill = true if @@pools.empty?
+        end
+        
+        # Modified Queue to properly interact with Pool
+        class PoolQueue < Queue
+        
+            def initialize
+                super
+                @lock = Mutex.new
+            end
+            
+            def <<(val)
+                @lock.synchronize do
+                    super
+                    Pool.wakeup_threads
+                end
+            end
+            
+            def push(val)
+                @lock.synchronize do
+                    super
+                    Pool.wakeup_threads
+                end
+            end
+            
+            def pop
+                @lock.synchronize do
+                    if(size > 0)
+                        super
+                    else
+                        raise Exceptions::BotException.new("Queue is currently empty")
+                    end
+                end
+            end
+                
+        end
     
     end
 

data/lib/mod_spox/Socket.rb

@@ -39,6 +39,7 @@ module ModSpox
         def connect
             Logger.log("Establishing connection to #{@server}:#{@port}", 10)
             @socket = TCPSocket.new(@server, @port)
+            @socket.sync = true
             server = Models::Server.find_or_create(:host => @server, :port => @port)
             server.connected = true
             server.save
@@ -58,7 +59,7 @@ module ModSpox
         # new_burst:: Number of lines allowed in burst
         # Resets the burst
         def burst=(new_burst)
-            raise Exceptions::InvalidValue('Burst value must be a positive number') unless new_busrt.to_i > 0
+            raise Exceptions::InvalidValue('Burst value must be a positive number') unless new_burst.to_i > 0
             @burst = new_burst
         end
         
@@ -84,7 +85,7 @@ module ModSpox
             @last_send = Time.new
             @sent += 1
             @check_burst += 1
-            @check_time = Time.now if @check_time.nil?
+            @check_time = Time.now.to_i if @check_time.nil?
         end
         
         # Retrieves a string from the server
@@ -126,11 +127,11 @@ module ModSpox
             @writer_thread = Thread.new{
                 until @kill do
                     write(@sendq.pop)
-                    if((Time.now - @check_time) > @burst_in && @check_burst > @burst)
-                        sleep(@delay)
+                    if((Time.now.to_i - @check_time) > @burst_in)
                         @check_time = nil
                         @check_burst = 0
-                    elsif((Time.now - @check_time) > @burst_in && @check_burst < @burst)
+                    elsif((Time.now.to_i - @check_time) >= @burst_in && @check_burst >= @burst)
+                        sleep(@delay)
                         @check_time = nil
                         @check_burst = 0
                     end
@@ -145,7 +146,6 @@ module ModSpox
                     Kernel.select([@socket], nil, nil, nil)
                     @factory << read
                 end
-                @sendq.clear
             }
         end
         

data/lib/mod_spox/Timer.rb

@@ -3,14 +3,12 @@ module ModSpox
     class Timer < Pool
     
         # pipeline:: message pipeline
-        # procs:: number of threads in the pool
         # Create a new Timer
-        def initialize(pipeline, procs=2)
-            super(procs)
+        def initialize(pipeline)
+            super()
             @pipeline = pipeline
             @timers = Array.new
-            @actions = Queue.new
-            Logger.log("Created queue: #{@actions} in timer", 10)
+            Logger.log("Created queue: #{@queue} in timer", 10)
             @monitor = Monitors::Timer.new
             @thread = nil
             @stop_timer = false
@@ -105,7 +103,7 @@ module ModSpox
         
         # Clears all actions in the timer's queue
         def clear
-            @actions.clear
+            @queue.clear
             @timers.clear
         end
         
@@ -117,14 +115,14 @@ module ModSpox
             for action in @timers do
                 action.tick(time_passed)
                 if(action.due?)
-                    @actions << action.schedule
+                    @queue << action.schedule
                 end
             end
         end
         
         # Process the actions
         def processor
-            action = @actions.pop
+            action = @queue.pop
             begin
                 action.run
                 remove(action) if action.is_complete?

data/lib/mod_spox/handlers/Handler.rb

@@ -10,7 +10,7 @@ module ModSpox
             protected
             
             def find_model(string)
-                if(string =~ /^[A-Za-z\|\\\{\}\[\]\^\`~\_\-]+$/)
+                if(string =~ /^[A-Za-z\|\\\{\}\[\]\^\`~\_\-]+[A-Za-z0-9\|\\\{\}\[\]\^\`~\_\-]*$/)
                     Logger.log("Model: #{string} -> Nick")
                     return Models::Nick.find_or_create(:nick => string)
                 elsif(string =~ /^[&#+!]/)

data/lib/mod_spox/handlers/Privmsg.rb

@@ -17,6 +17,7 @@ module ModSpox
                         source.source = base_source
                         source.save
                     end
+                    Models::NickChannel.find_or_create(:channel_id => target.pk, :nick_id => source.pk) if target.is_a?(ModSpox::Models::Channel)
                     return Messages::Incoming::Privmsg.new(string, source, target, message)
                 else
                     Logger.log('Failed to match PRIVMSG message')

data/lib/mod_spox/handlers/Who.rb

@@ -35,6 +35,7 @@ module ModSpox
                     @raw_cache[location] << string
                     if(location[0].chr !~ /[A-Za-z]/)
                         channel = find_model(location)
+                        Models::NickChannel.find_or_create(:channel_id => channel.pk, :nick_id => nick.pk)
                         if(info.include?('+'))
                             Models::NickMode.find_or_create(:channel_id => channel.pk, :nick_id => nick.pk, :mode => 'v')
                         elsif(info.include?('@'))