mod_spox 0.1.0.1 → 0.2.0

data/data/mod_spox/extras/Confess.rb

@@ -13,11 +13,19 @@ class Confess < ModSpox::Plugin
         begin
             require 'htmlentities'
         rescue Object => boom
-            Logger.log('Error: This plugin requires the HTMLEntities gem. Please install and reload plugin.')
+            Logger.warn('Error: This plugin requires the HTMLEntities gem. Please install and reload plugin.')
             raise Exceptions::BotException.new("Missing required HTMLEntities library")
         end
-        Confession.create_table unless Confession.table_exists?
-        Signature.find_or_create(:signature => 'confess ?(.+)?', :plugin => name, :method => 'confess',
+        begin
+            Confession.db = Sequel.sqlite(BotConfig[:userpath] + '/confessions.db')
+        rescue Object => boom
+            Logger.warn("Error: Unable to initialize this plugin: #{boom}")
+            raise Exceptions::BotException.new("Failed to create database: #{boom}")
+        end
+        Confession.build_confession && Confession.create_table unless Confession.table_exists?
+        Signature.find_or_create(:signature => 'confess', :plugin => name, :method => 'confess',
+            :description => 'Print a confession')
+        Signature.find_or_create(:signature => 'confess (?!score|count|fetcher|\+\+|\-\-)(.+)?', :plugin => name, :method => 'confess',
             :description => 'Print a confession').params = [:term]
         Signature.find_or_create(:signature => 'confess(\+\+|\-\-) ?(\d+)?', :plugin => name, :method => 'score',
             :description => 'Score a confession').params = [:score, :id]
@@ -30,62 +38,100 @@ class Confess < ModSpox::Plugin
         Config[:confess] = 'nofetch' if Config[:confess].nil?
         @last_confession = {}
         @fetch = false
-        @mutex = Mutex.new
         @coder = HTMLEntities.new
+        @timer = {:action => nil, :id => nil}
+        @lock = Mutex.new
         start_fetcher if Config[:confess] == 'fetch'
     end
     
+    def destroy
+        Confession.db.disconnect
+    end
+    
     def confess(message, params)
-        c = nil
-        reg = false
-        if(params[:term])
-            if(params[:term] =~ /^\d+$/)
-                c = Confession[params[:term].to_i]
+        begin
+            c = nil
+            pk = nil
+            @lock.synchronize do
+                if(params[:term])
+                    return if params[:term] == 'count'
+                    if(params[:term] =~ /^\d+$/)
+                        c = Confession[params[:term].to_i]
+                    else
+                        cs = Confession.search(params[:term])
+                        Logger.info("Size of confession results: #{cs.size}")
+                        rand_idx = rand(cs.size - 1)
+                        rand_id = cs[rand_idx].to_i
+                        Logger.info("Random index to be used: #{rand_idx}")
+                        Logger.info("Random ID to be used for confession: #{rand_id}")
+                        c = Confession[rand_id]
+                    end
+                else
+                    c = Confession[rand(Confession.count) - 1]
+                end
+                unless c.nil?
+                    pk = c.pk
+                    c = c.confession
+                end
+            end
+            if(c)
+                reply message.replyto, "\2[#{pk}]\2: #{c}"
+                @last_confession[message.target.pk] = pk
             else
-                c = Confession.filter(:confession => Regexp.new(params[:term])).first
-                reg = true
+                reply message.replyto, "\2Error:\2 Failed to find confession"
             end
-        else
-            ids = Confession.select(:id).map(:id)
-            c = Confession[ids[rand(ids.size - 1)].to_i]
-        end
-        if(c)
-            reply message.replyto, "\2[#{c.pk}]\2: #{reg ? c.confession.gsub(/(#{params[:term]})/, "\2\\1\2") : c.confession}"
-            @last_confession[message.target.pk] = c.pk
-        else
-            reply message.replyto, "\2Error:\2 Failed to find confession"
+        rescue Object => boom
+            reply message.replyto, "Failed to locate a match. Error encountered: #{boom}"
         end
     end
     
     def show_score(message, params)
-        c = Confession[params[:id].to_i]
-        if(c)
-            reply message.replyto, "\2[#{c.pk}]:\2 #{c.score.to_i}% of raters gave this confession a positive score"
+        pk = nil
+        score = nil
+        c = nil
+        @lock.synchronize do
+            c = Confession[params[:id].to_i]
+            if(c)
+                pk = c.pk
+                score = c.score.to_i
+            end
+        end
+        if(pk)
+            reply message.replyto, "\2[#{pk}]:\2 #{score}% of raters gave this confession a positive score"
         else
             reply message.replyto, "\2Error:\2 Failed to find confession with ID: #{params[:id]}"
         end
     end
     
     def score(message, params)
-        if(params[:id])
-            c = Confession[params[:id].to_i]
-        else
-            c = Confession[@last_confession[message.target.pk]] if @last_confession.has_key?(message.target.pk)
+        c = nil
+        @lock.synchronize do
+            if(params[:id])
+                c = Confession[params[:id].to_i]
+            else
+                c = Confession[@last_confession[message.target.pk]] if @last_confession.has_key?(message.target.pk)
+            end
         end
         if(c)
-            if(params[:score] == '++')
-                c.update_with_params(:positive => c.positive.to_i + 1)
-            else
-                c.update_with_params(:negative => c.negative.to_i + 1)
+            @lock.synchronize do
+                if(params[:score] == '++')
+                    c.update_with_params(:positive => c.positive.to_i + 1)
+                else
+                    c.update_with_params(:negative => c.negative.to_i + 1)
+                end
+                c.update_with_params(:score => ((c.positive.to_f) / (c.positive.to_f + c.negative.to_f)) * 100.0)
             end
-            c.update_with_params(:score => ((c.positive.to_f) / (c.positive.to_f + c.negative.to_f)) * 100.0)
         else
             reply message.replyto, "\2Error:\2 Failed to find confession to score"
         end
     end
     
     def count(message, params)
-        reply message.replyto, "Current number of stored confessions: #{Confession.all.size}"
+        c = 0
+        @lock.synchronize do
+            c = Confession.count
+        end
+        reply message.replyto, "Current number of stored confessions: #{c}"
     end
     
     def fetcher(message, params)
@@ -100,6 +146,7 @@ class Confess < ModSpox::Plugin
         else
             if(Config[:confess] == 'fetch')
                 Config[:confess] = 'nofetch'
+                stop_fetcher
                 reply message.replyto, 'Confession fetcher has been stopped'
             else
                 reply message.replyto, 'Confession fetcher is not currently running'
@@ -109,58 +156,90 @@ class Confess < ModSpox::Plugin
     
     def grab_page
         begin
-            connection = Net::HTTP.new('beta.grouphug.us', 80)
-            response = connection.request_get('/random', nil)
+            connection = Net::HTTP.new('www.grouphug.us', 80)
+            response = connection.request_get("/frontpage?page=#{rand(17349)+1}", nil)
             response.value
             page = response.body.gsub(/[\r\n]/, ' ')
-            Logger.log("Processing matches")
+            Logger.info("Processing matches")
             page.scan(/<div class="content">\s*<p>\s*(.+?)\s*<\/p>\s*<\/div>/).each{|match|
-                Logger.log("Match found: #{match[0]}")
+                Logger.info("Match found: #{match[0]}")
                 conf = CGI::unescapeHTML(match[0])
                 conf = conf.gsub(/<.+?>/, ' ').gsub(/[\r\n]/, '').gsub(/\s+/, ' ')
                 conf = @coder.decode(conf)
-                Logger.log("Match turned into: #{conf}")
+                Logger.info("Match turned into: #{conf}")
                 if conf.length < 300
                     begin
-                        Confession.new(:confession => conf, :hash => Digest::MD5.hexdigest(conf)).save
+                        @lock.synchronize do
+                            c = Confession.new(:hash => Digest::MD5.hexdigest(conf)).save
+                            c.confession = conf 
+                        end
                     rescue Object => boom
-                        Logger.log 'Warning: Fetched confession already found in database'
+                        Logger.warn('Warning: Fetched confession already found in database')
                     end
                 end
             }
         rescue Object => boom
-            Logger.log "Error fetching data: #{boom}"
-        end
-        if(Config[:confess] == 'fetch')
-            @pipeline << Messages::Internal::TimerAdd.new(self, rand(500), nil, true){ grab_page }
-        else
-            stop_fetcher
+            Logger.warn("Error fetching data: #{boom}")
+        ensure
+            @timer[:action].reset_period(rand(1000)+1) unless @timer[:action].nil?
         end
     end
     
     private
     
     def start_fetcher
-        @mutex.synchronize do
-            grab_page unless @fetch
+        if(@timer[:action].nil?)
+            m = Messages::Internal::TimerAdd.new(self, rand(1000)+1){ grab_page }
+            @timer[:id] = m.id
+            @pipeline << m
+        end
+    end
+    
+    def get_timer(m)
+        if(m.id == @timer[:id])
+            if(m.action_added?)
+                @timer[:action] = m.action
+            else
+                @timer = {:action => nil, :id => nil}
+            end
         end
     end
     
     def stop_fetcher
-        @mutex.synchronize do
-            @fetch = false
+        unless(@timer[:action].nil?)
+            @pipeline << Messages::Internal::TimerRemove(@timer[:action])
         end
     end
 
-    class Confession < Sequel::Model
+    class Confession < Sequel::Model    
+        def Confession.build_confession
+            db << 'CREATE VIRTUAL TABLE `confessions_confession` USING FTS3(`confession` TEXT NOT NULL)'
+        end
+        
         set_schema do
-            text :confession, :null => false
             text :hash, :null => false, :unique => true
             integer :positive, :null => false, :default => 0
             integer :negative, :null => false, :default => 0
             float :score, :null => false, :default => 0
             primary_key :id
         end
+        
+        def confession=(c)
+            if(confession)
+                db[:confessions_confession].filter('docid = ?', pk).update(:confession => c)
+            else
+                db[:confessions_confession] << {:docid => pk, :confession => c}
+            end
+        end
+        
+        def confession
+            c = db[:confessions_confession].select(:confession).where('docid = ?', pk).first
+            return c.nil? ? nil : c[:confession]
+        end
+        
+        def Confession.search(terms)
+            results = db['select docid from confessions_confession where confession match ?', terms].map(:docid)
+        end
     end
 
 end

data/data/mod_spox/extras/DCC.rb

@@ -0,0 +1,189 @@
+['ipaddr', 'socket', 'timeout'].each{|f| require f}
+
+class DCC < ModSpox::Plugin
+
+    include Models
+
+    def initialize(pipeline)
+        super
+        group = Group.find_or_create(:name => 'dcc')
+        admin = Group.find_or_create(:name => 'admin')
+        Signature.find_or_create(:signature => 'file list(\s(.+))?', :plugin => name, :method => 'file_list',
+            :description => 'List available DCC files', :group_id => group.pk).params = [:pattern]
+        Signature.find_or_create(:signature => 'file get (.+)', :plugin => name, :method => 'file_get',
+            :description => 'Download file', :group_id => group.pk).params = [:filename]
+        Signature.find_or_create(:signature => 'file ports (\d+)-(\d+)', :plugin => name, :method => 'set_ports',
+            :description => 'Set allowed DCC ports', :group_id => admin.pk).params = [:start, :end]
+        Signature.find_or_create(:signature => 'file adddir (.+)', :plugin => name, :method => 'add_dir',
+            :description => 'Add directory to file list', :group_id => admin.pk).params = [:dir]
+        Signature.find_or_create(:signature => 'file rmdir (\d+)', :plugin => name, :method => 'rm_dir',
+            :description => 'Remove directory from file list', :group_id => admin.pk).params = [:dir]
+        Signature.find_or_create(:signature => 'file show dir', :plugin => name, :method => 'show_dirs',
+            :description => 'Show directories available to file list', :group_id => admin.pk)
+        Signature.find_or_create(:signature => 'file show ports', :plugin => name, :method => 'show_ports',
+            :description => 'Show allowed ports', :group_id => admin.pk)
+        Signature.find_or_create(:signature => 'file max wait(\s(\d+))?', :plugin => name, :method => 'max_wait',
+            :description => 'Show/set timeout for accepting files', :group_id => admin.pk).params = [:wait]
+        Signature.find_or_create(:signature => 'dcc chat', :plugin => name, :method => 'dcc_chat',
+            :description => 'Start a DCC chat with the bot (useful if behind firewall', :group_id => group.pk)
+        @servers = {}
+        @ports = Setting[:dcc_ports]
+        @ports = {:start => 49152, :end => 65535} if @ports.nil?
+        @dirs = Setting.find_or_create(:name => 'dcc_dirs').value
+        @dirs = [] unless @dirs.is_a?(Array)
+        @max_wait = Setting[:dcc_max_wait]
+        @max_wait = @max_wait.nil? ? 60 : @max_wait.to_i
+    end
+
+    def file_list(message, params)
+        matches = []
+        pattern = params[:pattern] ? Regexp.new(params[:pattern].strip!) : nil
+        @dirs.each do |path|
+            dir = Dir.new(path)
+            dir.each do |file|
+                next if File.directory?("#{dir.path}/#{file}") || (file[0] == 46 || file[0] == '.') || !File.readable?("#{dir.path}/#{file}")
+                unless(pattern.nil?)
+                    if(pattern.match(file))
+                        matches << dir.path + '/' + file + " - #{Helpers.format_size(File.size(dir.path + '/' + file))}"
+                    end
+                else
+                    matches << dir.path + '/' + file  + " - #{Helpers.format_size(File.size(dir.path + '/' + file))}"
+                end
+            end
+        end
+        output = ["\2Files in available list:\2 (matching: #{params[:pattern] ? params[:pattern] : ''})"]
+        output = output + matches
+        reply message.replyto, output
+    end
+
+    def file_get(message, params)
+        @try = 0
+        socket = nil
+        port = 0
+        unless(@dirs.include?(File.dirname(params[:filename])))
+            reply message.replyto, "\2Error:\2 #{params[:filename]} is not within the allowed directories"
+        else
+            while(socket.nil? && @try < 3) do
+                begin
+                    port = rand(@ports[:end] - @ports[:start]) + @ports[:start]
+                    socket = Object::Socket.new(Object::Socket::AF_INET, Object::Socket::SOCK_STREAM, 0)
+                    addr = Object::Socket.pack_sockaddr_in(port, me.address)
+                    socket.bind(addr)
+                    initialize_getter(socket, params[:filename])
+                rescue Object => boom
+                    Logger.warn("Failed to initialize DCC TCPServer. Reason: #{boom}")
+                    @try += 1
+                    socket = nil
+                    port = nil
+                end
+            end
+            if(socket.nil?)
+                reply message.replyto, "\2Error:\2 Failed to initialize file getter process."
+            else
+                ip = IPAddr.new(me.address).to_i
+                @pipeline << Messages::Outgoing::Privmsg.new(message.source, "SEND #{File.basename(params[:filename])} #{ip} #{port} #{File.size(params[:filename])}", false, true, 'DCC')
+            end
+        end
+    end
+
+    def max_wait(message, params)
+        wait = params[:wait].nil? ? nil : params[:wait].strip
+        unless(wait.nil?)
+            @max_wait = wait.to_i
+            record = Setting.find_or_create(:name => 'dcc_max_wait')
+            record.value = wait
+            record.save
+            reply message.replyto, "Timeout for file download changed to: #{@max_wait} seconds"
+        else
+            reply message.replyto, "Timeout for file download is: #{@max_wait} seconds"
+        end
+    end
+
+    def set_ports(message, params)
+        if(params[:start].to_i > 1024 && params[:end].to_i < 65536)
+            @ports = {:start => params[:start].to_i, :end => params[:end].to_i}
+            record = Setting.find_or_create(:name => 'dcc_ports')
+            record.value = @ports
+            record.save
+            reply message.replyto, "File ports have been updated to: #{@ports[:start]} - #{@ports[:end]}"
+        else
+            reply message.replyto, "\2Error:\2 Ports given are out of acceptable range (1025 - 65535)"
+        end
+    end
+
+    def add_dir(message, params)
+        if(File.readable?(params[:dir]))
+            if(@dirs.include?(dir))
+                reply message.replyto, "\2Error:\2 Given directory is already in available list. (#{params[:dir]})"
+            else
+                @dirs << dir
+                record = Setting.find_or_create(:name => 'dcc_dirs')
+                record.value = @dirs
+                record.save
+                reply message.replyto, "New directory added to DCC directory list: #{params[:dir]}"
+            end
+        else
+            reply message.replyto, "\2Error:\2 Given directory is not readable. (#{params[:dir]})"
+        end
+    end
+
+    def rm_dir(message, params)
+        if(@dirs.include?(params[:dir]))
+            @dirs.delete(params[:dir])
+            record = Setting.find_or_create(:name => 'dcc_dirs')
+            record.value = @dirs
+            record.save
+            reply message.replyto, "DCC directory successfully updated"
+        else
+            reply message.replyto, "\2Error:\2 Failed to find directory: #{params[:dir]} in available directory list"
+        end
+    end
+
+    def show_dirs(message, params)
+        output = []
+        output << "\2Directories available for DCC file list:\2"
+        output += @dirs
+        reply message.replyto, output
+    end
+
+    def show_ports(message, params)
+        reply message.replyto, "\2Allowed Ports:\2 #{@ports[:start]} - #{@ports[:end]}"
+    end
+
+    def dcc_chat(message, params)
+        @pipeline << Messages::Internal::DCCListener.new(message.source)
+    end
+
+    private
+
+    def initialize_getter(socket, filename)
+        @servers[socket.object_id] = Thread.new do
+            client = nil
+            addrinfo = nil
+            cport = nil
+            cip = nil
+            begin
+                Timeout::timeout(@max_wait) do
+                    socket.listen(5)
+                    client, addrinfo = socket.accept
+                    cport, cip = Object::Socket.unpack_sockaddr_in(addrinfo)
+                end
+                Logger.info("Sending file: #{filename} to IP: #{cip}:#{cport}")
+                file = File.new(filename)
+                until((line = file.gets).nil?) do
+                    client << line
+                end
+                Logger.info("Sending of file: #{filename} to IP: #{addrinfo} is now complete")
+            rescue Timeout::Error => boom
+                Logger.warn("Error sending file: #{filename}. Timeout exceeded (#{@max_wait} seconds)")
+            rescue Object => boom
+                Logger.warn("Error sending file: #{filename}. Unknown reason: #{boom}")
+            ensure
+                socket.close
+                client.close
+                @servers.delete(socket.object_id)
+            end
+        end
+    end
+
+end

data/data/mod_spox/extras/DevWatch.rb

@@ -19,12 +19,10 @@ class DevWatch < ModSpox::Plugin
         if(Setting[:devwatch].nil?)
             Setting.find_or_create(:name => 'devwatch').value = {:channels => [], :interval => 300}
         end
-        @pipeline.hook(self, :timer_response, :Internal_TimerResponse)
         @original = nil
         @new = nil
-        @timer = nil
-        @lock = Mutex.new
-        run
+        @timer = {:action => nil, :id => nil}
+        start_auto
     end
     
     def enable_watch(message, params)
@@ -39,7 +37,7 @@ class DevWatch < ModSpox::Plugin
                 reply(message.replyto, "#{channel.name} has been removed from the development watch list")
             end
             Setting.filter(:name => 'devwatch').first.value = vals
-            run
+            update_auto
         else
             reply(message.replyto, "\2Error:\2 I have no record of #{params[:channel]}.")
         end
@@ -61,7 +59,7 @@ class DevWatch < ModSpox::Plugin
             vals[:url] = params[:url]
             reply(message.replyto, "OK")
             Setting.filter(:name => 'devwatch').first.value = vals
-            run
+            update_auto
         else
             if(Setting[:devwatch].has_key?(:url))
                 reply(message.replyto, "\2Devwatch URL:\2 #{Setting[:devwatch][:url]}")
@@ -76,38 +74,17 @@ class DevWatch < ModSpox::Plugin
             vals = Setting[:devwatch]
             vals[:interval] = params[:time].to_i
             Setting.filter(:name => 'devwatch').first.value = vals
-            @timer.reset_period(params[:time].to_i) unless @timer.nil?
+            if(@timer[:action].nil?)
+                update_auto
+            else
+                @timer[:action].reset_period(params[:time].to_i)
+            end
             reply(message.replyto, "Devwatch announcement interval reset to: #{Helpers.format_seconds(params[:time].to_i)}")
         else
             reply(message.replyto, "Devwatch announcement interval set to: #{Helpers.format_seconds(Setting[:devwatch][:interval].to_i)}")
         end
     end
     
-    def run
-        @lock.synchronize do
-            check_updates
-            if(Setting[:devwatch].has_key?(:url) && Setting[:devwatch][:channels].size > 0)
-                if(@timer.nil?)
-                    @pipeline << ModSpox::Messages::Internal::TimerAdd.new(self, Setting[:devwatch][:interval].to_i){check_updates}
-                    sleep(0.01) while @timer.nil?
-                end
-            else
-                if(@timer)
-                    @pipeline << ModSpox::Messages::Internal::TimerRemove.new(@timer)
-                    sleep(0.01) until @timer.nil?
-                end
-            end
-        end
-    end
-    
-    def timer_response(message)
-        if(message.origin == self && message.action_added?)
-            @timer = message.action
-        elsif(message.action == @timer && message.action_removed?)
-            @timer = nil
-        end
-    end
-    
     def check_updates
         if(Setting[:devwatch].has_key?(:url) && Setting[:devwatch][:channels].size > 0)
             src = open(Setting[:devwatch][:url])
@@ -117,7 +94,7 @@ class DevWatch < ModSpox::Plugin
                     @original = item.elements['title'].text
                     break
                 end
-                Logger.log("Initialized development watch RSS feed: #{@original}")
+                Logger.info("Initialized development watch RSS feed: #{@original}")
             else
                 @new = doc
                 print_new
@@ -150,5 +127,27 @@ class DevWatch < ModSpox::Plugin
             end
         end
     end
+    
+    def get_timer(m)
+        if(m.id == @timer[:id])
+            @timer[:action] = m.action_added? ? m.action : nil
+        end
+    end
+    
+    def update_auto
+        unless(@timer[:action].nil?)
+            @pipeline << Messages::Internal::TimerRemove.new(@timer[:action])
+        end
+        sleep(0.01)
+        start_auto
+    end
+    
+    def start_auto
+        if(@timer[:action].nil? && Setting[:devwatch].has_key?(:url) && Setting[:devwatch][:channels].size > 0)
+            m = Messages::Internal::TimerAdd.new(self, Setting[:devwatch][:interval].to_i){ check_updates }
+            @timer[:id] = m.id
+            @pipeline << m
+        end
+    end
 
 end