mod_spox 0.0.1

data/lib/mod_spox/ConfigurationWizard.rb

@@ -0,0 +1,178 @@
+['etc', 'termios', 'mod_spox/Loader',
+ 'mod_spox/BotConfig',  'mod_spox/BaseConfig'].each{|f|require f}
+
+
+module ModSpox
+
+    class ConfigurationWizard
+    
+        def initialize
+            @echo = nil
+            @config = Array.new
+            @config << {:id => :db_username, :string => 'Database username: ', :regex => '[a-zA-Z].*', :default => 'mod_spox', :value => nil, :echo => true}
+            @config << {:id => :db_password, :string => 'Database password: ', :regex => '.*', :default => nil, :value => nil, :echo => false}
+            @config << {:id => :db_host, :string => 'Database host: ', :regex => '.+', :default => 'localhost', :value => nil, :echo => true}
+            @config << {:id => :db_database, :string => 'Database name: ', :regex => '.+', :default => 'mod_spox', :value => nil, :echo => true}
+            @config << {:id => :db_adapter, :string => 'Database type (mysql|pgsql|sqlite): ', :regex => '(mysql|pgsql|sqlite)', :default => nil, :value => nil, :echo => true}
+            @config << {:id => :irc_server, :string => 'IRC Server: ', :regex => '.+', :default => nil, :value => nil, :echo => true}
+            @config << {:id => :irc_port, :string => 'IRC Port: ', :regex => '[0-9]+', :default => nil, :value => nil, :echo => true}
+            @config << {:id => :reconnect_wait, :string => 'Reconnect wait time: ', :regex => '[0-9]+', :default => '10', :value => nil, :echo => true}
+            @config << {:id => :bot_nick, :string => 'IRC Nick: ', :regex => '[a-zA-Z].*', :default => 'mod_spox', :value => nil, :echo => true}
+            @config << {:id => :bot_password, :string => 'IRC Nick Password: ', :regex => '.*', :default => nil, :value => nil, :echo => false}
+            @config << {:id => :bot_username, :string => 'IRC Username: ', :regex => '.+', :default => 'mod_spox', :value => nil, :echo => true}
+            @config << {:id => :bot_realname, :string => 'IRC Real Name: ', :regex => '.+', :default => 'mod_spox IRC bot', :value => nil, :echo => true}
+            @config << {:id => :socket_burst, :string => 'Socket burst rate (lines): ', :regex => '[0-9]+', :default => '3', :value => nil, :echo => true}
+            @config << {:id => :socket_burst_in, :string => 'Socket burst time: ', :regex => '[0-9]+', :default => '2', :value => nil, :echo => true}
+            @config << {:id => :socket_burst_delay, :string => 'Socket burst delay: ', :regex => '[0-9]+', :default => '2', :value => nil, :echo => true}
+            @config << {:id => :admin_nick, :string => 'Administrator nick: ', :regex => '[a-zA-Z].*', :default => nil, :value => nil, :echo => true}
+            @config << {:id => :admin_password, :string => 'Administrator password: ', :regex => '.+', :default => nil, :value => nil, :echo => false}
+            @config << {:id => :plugin_directory, :string => 'Plugin directory (bot must have write priviliges): ', :regex => '.+', :default => nil, :echo => true}
+            @config << {:id => :trigger, :string => 'Trigger character for plugins: ', :regex => '.', :default => '!', :value => nil, :echo => true}            
+        end
+    
+        # Run the configuration wizard
+        def run
+            puts "*********************************"
+            puts "* mod_spox Configuration Wizard *"
+            puts "*********************************"
+            puts ""
+            @config.each{|v|
+                v[:value] = get_input(v[:string], v[:regex], v[:echo], v[:default])
+            }
+            print "Storing configuration values... "
+            save_configuration
+            puts "OK"
+            puts "mod_spox is now configured and ready for use"
+        end
+        
+        private
+        
+        def find(key)
+            @config.each{|c|
+                if(c[:id] == key)
+                    return c[:value]
+                end
+            }
+            return nil
+        end
+        
+        # Save our configuration values
+        def save_configuration
+            config = BaseConfig.new(BotConfig[:userconfigpath])
+            @config.each{|value|
+                config[value[:id]] = value[:value] if value[:id].to_s =~ /^db/
+            }
+            config.write_configuration
+            initialize_bot
+            create_databases
+            #Migrators.constants.each{|m| Migrators.const_get(m).apply(Database.db, :up)}
+            @config.each{|value|
+                Models::Config[value[:id]] = value[:value] unless value[:id].to_s =~ /^(db|irc|admin|trigger)/
+            }
+            s = Models::Server.find_or_create(:host => find(:irc_server), :port => find(:irc_port))
+            n = Models::Nick.find_or_create(:nick => find(:admin_nick))
+            a = Models::Auth.find_or_create(:nick_id => n.pk)
+            a.group = Models::Group.find_or_create(:name => 'admin')
+            a.password = find(:admin_password)
+            a.save
+            t = Models::Trigger.find_or_create(:trigger => find(:trigger))
+            t.active = true
+            t.save
+        end
+        
+        # echo:: echo user input
+        # Turns echoing of user input on or off
+        def input_echo(echo=true)
+            return if echo == @echo
+            term = Termios::getattr($stdin)
+            term.c_lflag |= Termios::ECHO if echo
+            term.c_lflag &= ~Termios::ECHO unless echo
+            Termios::setattr($stdin, Termios::TCSANOW, term)
+            @echo = echo
+        end
+        
+        # pattern:: regex response must match
+        # default:: default value if response is empty
+        # echo:: echo user's input
+        # Reads users input
+        def read_input(pattern=nil, default=nil, echo=true)
+            input_echo(echo)
+            response = $stdin.readline
+            response.strip!
+            set = response.length > 0
+            unless(pattern.nil?)
+                response = nil unless response =~ /^#{pattern}$/
+            end
+            if(default && response.nil? && !set)
+                response = default
+            end
+            input_echo(true) unless echo
+            puts "" unless echo
+            return response
+        end
+        
+        # output:: text to send before user input
+        # regex:: pattern user input must match (^ and $ not need. applied automatically)
+        # echo:: echo user's input
+        # default:: default value if no value is entered
+        def get_input(output, regex, echo=true, default=nil)
+            response = nil
+            until(response) do
+                print output
+                print "[#{default}]: " unless default.nil?
+                response = read_input(regex, default, echo)
+            end
+            return response
+        end
+        
+        def create_databases
+            case Database.type
+                when :mysql
+                    Database.db << "CREATE TABLE IF NOT EXISTS nicks (id int not null auto_increment primary key, nick varchar(255) unique not null, username varchar(255), real_name varchar(255), address varchar(255), source varchar(255), connected_at timestamp, connected_to varchar(255), seconds_idle int, visible boolean not null default false, away boolean not null default false, botnick boolean not null default false)"
+                    Database.db << "CREATE TABLE IF NOT EXISTS channels (id int not null auto_increment primary key, name varchar(255) not null, password varchar(255), autojoin boolean not null default false, topic varchar(255), quiet boolean not null default false, parked boolean not null default false)"
+                    Database.db << "CREATE TABLE IF NOT EXISTS auths (id int not null auto_increment primary key, password varchar(255), services boolean not null default false, mask varchar(255) unique, authed boolean not null default false, nick_id int unique references nicks)"
+                    Database.db << "CREATE TABLE IF NOT EXISTS channel_modes (id int not null auto_increment primary key, mode varchar(255) not null, channel_id int unique not null references channels)"
+                    Database.db << "CREATE TABLE IF NOT EXISTS configs (id int not null auto_increment primary key, name varchar(255) unique not null, value varchar(255))"
+                    Database.db << "CREATE TABLE IF NOT EXISTS nick_channels (channel_id int not null unique references channels, nick_id int not null unique not null references nicks, primary key(channel_id, nick_id))"
+                    Database.db << "CREATE TABLE IF NOT EXISTS nick_modes (id integer primary key auto_increment not null, mode varchar(255) not null, nick_id int not null references nicks, channel_id int references channels, unique index nick_modes_nick_id_channel_id_index (nick_id, channel_id))"
+                    Database.db << "CREATE TABLE IF NOT EXISTS servers (id int not null auto_increment primary key, host varchar(255) not null, port int not null default 6667, priority int not null default 0, connected boolean not null default false, unique index servers_server_port_index (server, port))"
+                    Database.db << "CREATE TABLE IF NOT EXISTS settings (id int not null auto_increment primary key, name varchar(255) not null unique, value text)"
+                    Database.db << "CREATE TABLE IF NOT EXISTS signatures (id int not null auto_increment primary key, signature varchar(255) not null, params varchar(255), group_id int default null references groups, method varchar(255) not null, plugin varchar(255) not null, description text)"
+                    Database.db << "CREATE TABLE IF NOT EXISTS triggers (id int not null auto_increment primary key, `trigger` varchar(255) unique not null, active boolean not null default false)"
+                    Database.db << "CREATE TABLE IF NOT EXISTS groups (id int not null auto_increment primary key, name varchar(255) not null unique)"
+                    Database.db << "CREATE TABLE IF NOT EXISTS auth_groups (auth_id int not null references auths, group_id int not null references groups, primary key(auth_id, group_id))"
+                when :pgsql
+                    Database.db << "CREATE TABLE nicks (id serial not null primary key, nick 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)"
+                    Database.db << "CREATE TABLE groups (id serial not null primary key, name text unique not null)"
+                    Database.db << "CREATE TABLE channel_modes (id serial not null primary key, mode text not null, channel_id integer unique not null references channels)"
+                    Database.db << "CREATE TABLE configs (id serial not null primary key, name text unique not null, value text)"
+                    Database.db << "CREATE TABLE nick_channels (channel_id integer not null references channels, nick_id integer not null references nicks, primary key(nick_id, channel_id))"
+                    Database.db << "CREATE TABLE nick_modes (id serial not null primary key, mode 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 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))"
+                when :sqlite
+                    Database.db << "CREATE TABLE if not exists nicks (id integer PRIMARY KEY AUTOINCREMENT, nick string UNIQUE NOT NULL COLLATE NOCASE, username string, real_name string, address string, source string, connected_at timestamp, connected_to string, seconds_idle integer, visible boolean NOT NULL DEFAULT 'f', away boolean NOT NULL DEFAULT 'f', botnick boolean NOT NULL DEFAULT 'f')"
+                    Database.db << "CREATE TABLE if not exists channels (id integer PRIMARY KEY AUTOINCREMENT, name string UNIQUE NOT NULL COLLATE NOCASE, password string, autojoin boolean NOT NULL DEFAULT 'f', topic string, quiet boolean NOT NULL DEFAULT 'f', parked boolean NOT NULL DEFAULT 'f')"
+                    Database.db << "CREATE TABLE if not exists auths (id integer PRIMARY KEY AUTOINCREMENT, password string, services boolean NOT NULL DEFAULT 'f', mask string UNIQUE, authed boolean NOT NULL DEFAULT 'f', nick_id integer UNIQUE REFERENCES nicks)"
+                    Database.db << "CREATE TABLE if not exists channel_modes (id integer PRIMARY KEY AUTOINCREMENT, mode string NOT NULL, channel_id integer UNIQUE NOT NULL REFERENCES channels)"
+                    Database.db << "CREATE TABLE if not exists configs (id integer PRIMARY KEY AUTOINCREMENT, name string UNIQUE NOT NULL, value string)"
+                    Database.db << "CREATE TABLE if not exists nick_channels (channel_id integer NOT NULL REFERENCES channels, nick_id integer NOT NULL REFERENCES nicks, primary key (channel_id, nick_id))"
+                    Database.db << "CREATE TABLE if not exists nick_modes (id integer PRIMARY KEY AUTOINCREMENT, mode string NOT NULL, nick_id integer NOT NULL REFERENCES nicks, channel_id integer REFERENCES channels)"
+                    Database.db << "CREATE UNIQUE INDEX if not exists nick_modes_nick_id_channel_id_index ON nick_modes (nick_id, channel_id)"
+                    Database.db << "CREATE TABLE if not exists servers (id integer primary key autoincrement, host string NOT NULL, port integer NOT NULL DEFAULT 6667, priority integer NOT NULL DEFAULT 0, connected boolean NOT NULL DEFAULT 'f', unique index servers_server_port_index (server, 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 triggers (id integer PRIMARY KEY AUTOINCREMENT, trigger string UNIQUE NOT NULL, active boolean NOT NULL DEFAULT 'f')"            
+                    Database.db << "CREATE TABLE if not exists groups (id integer PRIMARY KEY AUTOINCREMENT, name string UNIQUE NOT NULL COLLATE NOCASE)"
+                    Database.db << "CREATE TABLE if not exists auth_groups(auth_id integer REFERENCES auths, group_id integer REFERENCES groups)"
+            end
+        end
+    
+    end
+
+end

data/lib/mod_spox/Database.rb

@@ -0,0 +1,25 @@
+module ModSpox
+
+    class Database
+    
+        def self.db=(database)
+            @@db = nil
+            @@db = database
+        end
+        
+        def self.type=(type)
+            @@type = nil
+            @@type = type
+        end
+        
+        def self.type
+            return Database.class_variable_defined?(:@@type) ? @@type : nil
+        end
+        
+        def self.db
+            return Database.class_variable_defined?(:@@db) ? @@db : nil
+        end
+    
+    end
+
+end

data/lib/mod_spox/Exceptions.rb

@@ -0,0 +1,35 @@
+module ModSpox
+    module Exceptions
+
+        class BotException < Exception
+        end
+        
+        class NotImplemented < BotException
+        end
+    
+        class InvalidType < BotException
+        end
+        
+        class InvalidValue < BotException
+        end
+        
+        class AlreadyRunning < BotException
+        end
+        
+        class NotRunning < BotException
+        end
+        
+        class UnknownKey < BotException
+        end
+        
+        class InstallationError < BotException
+        end
+        
+        class LockedObject < BotException
+        end
+        
+        class TimerInUse < BotException
+        end
+
+    end
+end

data/lib/mod_spox/Helpers.rb

@@ -0,0 +1,35 @@
+require 'timeout'
+module ModSpox
+    module Helpers
+        # secs:: number of seconds
+        # Converts seconds into a human readable string
+        def Helpers.format_seconds(secs)
+            d = (secs / 86400).to_i
+            secs = secs % 86400
+            m = (secs / 3600).to_i
+            secs = secs % 3600
+            str = Array.new
+            str << d == 1 ? "#{d} day" : "#{d} days" if d > 0
+            str << m == 1 ? "#{m} minute" : "#{m} minutes" if m > 0
+            str << secs == 1 ? "#{secs} second" : "#{secs} seconds" if secs > 0
+            return str.join(' ')
+        end
+        
+        # command:: command to execute
+        # timeout:: maximum number of seconds to run
+        # Execute a system command (use with care)
+        def Helpers.safe_exec(command, timeout=10)
+            begin
+                Timeout::timeout(timeout) do
+                    result = `#{command}`
+                end
+            rescue Timeout::Error => boom
+                Logger.log("Command execution exceeded allowed time (command: #{command} | timeout: #{timeout})")
+            rescue Object => boom
+                Logger.log("Command generated an exception (command: #{command} | error: #{boom})")
+            end
+        end
+                
+    
+    end
+end

data/lib/mod_spox/Loader.rb

@@ -0,0 +1,79 @@
+module ModSpox
+
+    # directory:: path to directory
+    # Requires all .rb files found within the given directory
+    # and all its subdirectories
+    def load_directory(directory='')
+        base = File.dirname(__FILE__)
+        Dir.new("#{base}/#{directory}").each{|item|
+            next if ['.', '..'].include?(item)
+            if(File.directory?("#{base}/#{directory}/#{item}"))
+                load_directory("#{directory}/#{item}")
+            elsif(item =~ /\.rb$/)
+                item = "#{directory}/#{item}" if directory.length > 0
+                begin
+                    require "mod_spox/#{item}"
+                rescue Object => boom
+                    @@failed << item
+                end
+            end
+        }
+        @@failed.each{|f| 
+            begin
+                require "mod_spox/#{f}"
+                @@failed.delete(f)
+            rescue Object => boom
+                # do nothing #
+            end
+        }
+    end
+    
+    # Loads all files needed by the bot
+    def initialize_bot
+        setup_adapter
+        @@failed = Array.new
+        load_directory
+        tries = 0
+        message = nil
+        until @@failed.empty? || tries > 5 do
+            @@failed.each{|f|
+                begin
+                    require "mod_spox/#{f}"
+                    @@failed.delete(f)
+                rescue Object => boom
+                    message = boom
+                end
+            }
+            tries += 1
+        end
+        if(tries > 5)
+            puts 'Failed'
+            puts "ERROR: Failed to load required libraries"
+            puts "Reason: #{message}"
+            puts "#{message.backtrace.join("\n")}"
+            exit
+        end
+    end
+    
+    # Setup the DataMapper adapter
+    def setup_adapter
+        require 'mod_spox/Exceptions'
+        require 'mod_spox/BotConfig'
+        require 'mod_spox/BaseConfig'
+        require 'mod_spox/Database'
+        config = BaseConfig.new(BotConfig[:userconfigpath])
+        case config[:db_adapter]
+            when 'mysql'
+                Database.db = Sequel.mysql(config[:db_database], :user => config[:db_username],
+                        :password => config[:db_password], :host => config[:db_host])
+                Database.type = :mysql
+            when 'pgsql'
+                Database.db = Sequel.open("postgres://#{config[:db_username]}:#{config[:db_password]}@#{config[:db_host]}/#{config[:db_database]}")
+                Database.type = :pgsql
+            when 'sqlite'
+                Database.db = Sequel.sqlite "#{BotConfig[:userpath]}/mod_spox.db"
+                Database.type = :sqlite
+        end
+    end
+
+end

data/lib/mod_spox/Logger.rb

@@ -0,0 +1,31 @@
+module ModSpox
+
+    class Logger
+        
+        # severity:: minimum severity for visible logging
+        # Sets the maximum level of visible logs
+        def self.severity(severity=1)
+            @@severity = severity
+        end
+        
+        # filedes:: file descriptor to log to
+        # Sets the file descriptor for logging. By default
+        # logs will be sent to STDOUT
+        def self.fd(filedes=nil)
+            @@fd = filedes.nil? ? $stdout : filedes
+        end
+        
+        # message:: message to log
+        # severity:: severity level (lower is more severe)
+        # Log a message. It is important to note that the lower the
+        # severity level of a message, the better chance it has of
+        # being outputted
+        def self.log(message, severity=1)
+            Logger.fd(nil) unless Logger.class_variable_defined?(:@@fd)
+            Logger.severity unless Logger.class_variable_defined?(:@@severity)
+            @@fd.puts("LOGGER [#{Time.now}]: #{message}") unless @@severity < severity
+        end
+        
+    end
+    
+end

data/lib/mod_spox/MessageFactory.rb

@@ -0,0 +1,73 @@
+module ModSpox
+
+    class MessageFactory < Pool
+    
+        # pipeline:: Message pipeline
+        # Create a new MessageFactory
+        def initialize(pipeline)
+            super(1)
+            @pipeline = pipeline
+            @handlers = Hash.new
+            @queue = Queue.new
+            Logger.log("Created new factory queue: #{@queue}", 15)
+            build_handlers
+            start_pool
+        end
+        
+        # string:: server message to be parsed
+        # Parses messages from server. This is placed in a queue to
+        # be processed thus there is now wait for processing to be
+        # completed.
+        def <<(string)
+            @queue << string
+        end
+        
+        # Builds the message handlers. This will load all Messages and Handlers
+        # found in the lib directory and then initialize all the Handlers
+        def build_handlers
+            # load our handlers in first
+            # note: the handlers add themselves to the @handlers hash
+            # during initialization
+            Handlers.constants.each{|name|
+                klass = Handlers.const_get(name)
+                if(klass < Handlers::Handler)
+                    Logger.log("Building handler: #{name}")
+                    begin
+                        klass.new(@handlers)
+                    rescue Object => boom
+                        Logger.log("ERROR: Failed to build handler: #{name} -> #{boom}")
+                    end
+                end
+            }
+            Logger.log("Handlers now available:", 15)
+            @handlers.each_pair{|k,v| Logger.log("#{k} -> #{v}", 15)}
+        end
+        
+        # message:: server message
+        # Parses the server message and passes it to the proper handler
+        def parse_message(message)
+            Logger.log("Processing message: #{message}", 15)
+            begin
+                if(message =~ /^:\S+ (\S+)/ || message =~ /^([A-Za-z0-9]+)\s/)
+                    key = $1
+                    key = key.to_sym unless key[0].chr =~ /\d/
+                    if(@handlers.has_key?(key))
+                        Logger.log("Message of type #{key} is now being handled by #{@handlers[key]}", 10)
+                        message = @handlers[key].process(message)
+                        @pipeline << message unless message.nil?
+                    end
+                end
+            rescue Object => boom
+                Logger.log("Failed to parse message from server: #{boom}\n#{boom.backtrace.join("\n")}")
+            end
+        end
+        
+        private
+        
+        def processor
+            parse_message(@queue.pop)
+        end
+    
+    end
+
+end

data/lib/mod_spox/Monitors.rb

@@ -0,0 +1,59 @@
+module ModSpox
+    module Monitors    
+        
+        # The Timer is a time based monitor (thus the
+        # "Timer" part of the name)
+        class Timer
+        
+            # Create a new Timer Monitor
+            def initialize
+                @threads = Array.new
+            end
+            
+            # Force the monitor to wake everyone up
+            def wakeup
+                @threads.each{|t|t.wakeup}
+                @threads.clear
+            end
+            
+            # How long the monitor should wait
+            def wait(time=nil)
+                @threads << Thread.current
+                if(time.nil?)
+                    sleep
+                else
+                    sleep(time)
+                end
+            end
+
+        end
+        
+        # The Boolean is a boolean based monitor (thus the
+        # "Boolean" part of the name)
+        class Boolean
+        
+            # Create a new Boolean Monitor
+            def initialize
+                @thread = nil
+            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
+            end
+            
+            # Start waiting
+            def wait
+                @thread = Thread.current
+                Logger.log("Stopping execution of thread: #{@thread}", 5)
+                Thread.stop
+            end
+        
+        end
+    end
+    
+end