spox-mod_spox 0.3.1

data/data/mod_spox/extras/AutoMode.rb

@@ -0,0 +1,122 @@
+require 'mod_spox/messages/outgoing/ChannelMode'
+class AutoMode < ModSpox::Plugin
+    
+    include Models
+    
+    def initialize(pipeline)
+        super
+        @admin = Group.find_or_create(:name => 'moder')
+        @user = Group.find_or_create(:name => 'modee')
+        add_sig(:sig => 'addop (\S+)', :method => :addop, :group => @admin, :desc => 'Add a nick to the auto op list', :req => 'public', :params => [:nick])
+        add_sig(:sig => 'addvoice (\S+)', :method => :addvoice, :group => @admin, :desc => 'Add a nick to the auto voice list', :req => 'public', :params => [:nick])
+        add_sig(:sig => 'op', :method => :op, :group => @user, :desc => 'Instruct bot to give you operator status', :req => 'public')
+        add_sig(:sig => 'voice', :method => :voice, :group => @user, :desc => 'Instruct bot to give you voice status', :req => 'public')
+        add_sig(:sig => 'automode list (\S+)', :method => :list, :group => @admin, :desc => 'Show list of current auto-modes for channel', :params => [:channel])
+        add_sig(:sig => 'delmode (\S+)', :method => :remove, :group => @admin, :desc => 'Remove nick from any auto-modes in channel', :req => 'public', :params => [:nick])
+        ModeRecord.create_table unless ModeRecord.table_exists?
+        @pipeline.hook(self, :check_join, :Incoming_Join)
+    end
+    
+    def addop(m, p)
+        nick = Helpers.find_model(p[:nick], false)
+        if(nick.is_a?(Nick))
+            ModeRecord.find_or_create(:nick_id => nick.pk, :channel_id => m.target.pk, :voice => false)
+            add_modee(nick)
+            reply m.replyto, "#{nick.nick} has been added to the auto-op list"
+        else
+            reply m.replyto, "\2Error:\2 Failed to find record of: #{p[:nick]}"
+        end
+    end
+    
+    def addvoice(m, p)
+        nick = Helpers.find_model(p[:nick], false)
+        if(nick.is_a?(Nick))
+            ModeRecord.find_or_create(:nick_id => nick.pk, :channel_id => m.target.pk, :voice => true)
+            add_modee(nick)
+            reply m.replyto, "#{nick.nick} has been added to the auto-voice list"
+        else
+            reply m.replyto, "\2Error:\2 Failed to find record of: #{p[:nick]}"
+        end
+    end
+    
+    def op(m, p)
+        record = ModeRecord.filter(:nick_id => m.source.pk, :channel_id => m.target.pk).first
+        if(record && !record.voice)
+            @pipeline << Messages::Outgoing::ChannelMode.new(m.target, '+o', m.source.nick) if me.is_op?(m.target)
+        else
+            reply m.replyto, "\2Error:\2 You are not listed on the auto-op list"
+        end
+    end
+    
+    def voice(m, p)
+        ModeRecord.filter(:nick_id => m.source.pk, :channel_id => m.target.pk).each do |record|
+            @pipeline << Messages::Outgoing::ChannelMode.new(m.target, '+v', m.source.nick) if me.is_op?(m.target) && record.voice
+        end
+    end
+    
+    def list(m, p)
+        channel = Helpers.find_model(p[:channel], false)
+        if(channel.is_a?(Channel))
+            records = ModeRecord.filter(:channel_id => channel.pk)
+            if(records.count > 0)
+                reply m.replyto, "\2Auto-Mode Listing:\2"
+                sleep(0.01)
+                records.each do |record|
+                    reply m.replyto, "#{record.nick.nick} \2->\2 #{record.voice == false ? "op" : "voice"}"
+                end
+            else
+                reply m.replyto, "\2Warning:\2 No users found in auto-mode list"
+            end
+        else
+            reply m.replyto, "\2Error:\2 Failed to find channel: #{p[:channel]}"
+        end
+    end
+    
+    def remove(m, p)
+        nick = Helpers.find_model(p[:nick], false)
+        if(nick.is_a?(Nick))
+            ModeRecord.filter(:channel_id => m.target.pk, :nick_id => nick.pk).destroy
+            remove_modee(nick)
+            reply m.replyto, "All auto-modes for user: #{p[:nick]} have been removed"
+        else
+            reply m.replyto, "\2Error:\2 Failed to find nick: #{p[:nick]}"
+        end
+    end
+    
+    def check_join(m)
+        return unless me.is_op?(m.channel)
+        matches = ModeRecord.filter(:nick_id => m.nick.pk, :channel_id => m.channel.pk)
+        if(matches.count > 0)
+            matches.each do |record|
+                mode = record.voice ? '+v' : '+o'
+                @pipeline << Messages::Outgoing::ChannelMode.new(m.channel, mode, m.nick.nick)
+            end
+        end
+    end
+    
+    def add_modee(nick)
+        modee = Group.find_or_create(:name => 'modee')
+        nick.group = modee
+    end
+    
+    def remove_modee(nick)
+        modee = Group.find_or_create(:name => 'modee')
+        if(ModeRecord.filter(:nick_id => nick.pk).count < 1)
+            nick.remove_group(modee)
+        end
+    end
+    
+    class ModeRecord < Sequel::Model
+        set_schema do
+            primary_key :id
+            boolean :voice, :null => false, :default => true
+            foreign_key :nick_id, :table => :nicks, :null => false
+            foreign_key :channel_id, :table => :channels, :null => false
+            index [:nick_id, :channel_id, :voice], :unique => true
+        end
+
+        many_to_one :channel, :class => ModSpox::Models::Channel
+        many_to_one :nick, :class => ModSpox::Models::Nick
+    end
+    
+end

data/data/mod_spox/extras/AutoRejoin.rb

@@ -0,0 +1,37 @@
+require 'mod_spox/messages/outgoing/Join'
+
+class AutoRejoin < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super
+        @pipeline.hook(self, :check_kick, :Incoming_Kick)
+        @pipeline.hook(self, :check_join, :Incoming_Join)
+        @pipeline.hook(self, :check_part, :Incoming_Part)
+        @pipeline.hook(self, :do_joins, :Incoming_Welcome)
+    end
+    
+    def check_kick(message)
+        if(message.kickee == me)
+            @pipeline << Messages::Outgoing::Join.new(message.channel)
+        end
+    end
+    
+    def check_join(m)
+        if(m.nick == me)
+            m.channel.update(:autojoin => true)
+        end
+    end
+    
+    def check_part(m)
+        if(m.nick == me)
+            m.channel.update(:autojoin => false)
+        end
+    end
+    
+    def do_joins(m)
+        Models::Channel.filter(:autojoin => true).each do |channel|
+            @pipeline << Messages::Outgoing::Join.new(channel)
+        end
+    end
+
+end

data/data/mod_spox/extras/Bash.rb

@@ -0,0 +1,55 @@
+# ex: set ts=4 et:
+require "net/http"
+require "cgi"
+
+# bash.org quote plugin
+# by pizza
+
+class Bash < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super
+        add_sig(:sig => 'bash( (top|latest|#\d+))?', :method => :random, :desc => 'Bash quote fetcher', :params => [:wspace, :cmd])
+        @site = 'http://bash.org/'
+    end
+    
+    def random(m, params)
+        begin
+            u = @site + '?top'
+            if 'latest' == params[:cmd]
+              u = @site + '?latest'
+            elsif /^#(\d+)$/.match(params[:cmd])
+              u = @site + '?' + $1
+            end
+            reply m.replyto, get_text(u)
+        rescue Object => boom
+            error m.replyto, "Failed to fetch. #{boom}"
+        end
+    end
+    
+    private
+    
+    def get_text(url)
+        begin
+            data = Net::HTTP.get_response(URI.parse(url)).body
+            # parse individual entries, they have a "qt" section within "quote"
+            m = data.scan(/<p class="qt">(.*?)<\/p>/m)
+            raise 'No quotes found' unless m.length > 0
+            if m.length > 1
+                m = m.delete_if{|x| x[0].length > 200 }
+                raise 'Only overly long quotes found' unless m.length > 0
+            end
+            i = rand(m.length)                  # NOTE: this works fine for individuals, since rand(1) is always 0
+            n = m[i][0].gsub(/<[^<]+>/, '')     # select a random quote
+            o = Helpers.convert_entities(n)     # unescape html entities
+            p = o.gsub("\r\n", " ").strip       # replace newlines with spaces and trim
+            q = p.gsub(/(<([^>]+)>(?:[^<]+))<\2>/){ $1 }    # replace duplicated name tags; condense lines
+            r = q.gsub(/\s{2,}/, ' ')           # condense spaces
+            return r
+        rescue Object => boom
+            Logger.error(boom)
+            raise boom
+        end
+    end
+end
+

data/data/mod_spox/extras/Bouncer.rb

@@ -0,0 +1,220 @@
+require 'openssl'
+
+class Bouncer < ModSpox::Plugin
+
+    def initialize(pipeline)
+        super
+        bounce = Group.find_or_create(:name => 'bouncer')
+        add_sig(:sig => 'bouncer port( (\d+))?', :method => :port, :group => bounce, :desc => 'Show or set bouncer port',
+            :params => [:port])
+        add_sig(:sig => 'bouncer (start|stop|restart)', :method => :do_service, :group => bounce, :desc => 'Start, stop, or restart bouncer')
+        add_sig(:sig => 'bouncer status', :method => :status, :group => bounce, :desc => 'Show current bouncer status')
+        add_sig(:sig => 'bouncer disconnect', :method => :disconnect, :group => bounce, :desc => 'Disconnect all connected clients')
+        add_sig(:sig => 'bouncer clients'< :method => :clients, :group => bounce, :desc => 'List clients connected to bouncer')
+        @pipeline.hook(self, :get_msgs, :Incoming)
+        @listener = nil
+        @clients = []
+        @socket = nil
+        @processor = nil
+        @to_server = Queue.new
+        start_listener if Models::Config.filter(:name => 'bouncer_port').count > 0
+    end
+    
+    def get_msgs(message)
+        unless(@clients.empty?)
+            Logger.info("Bouncer has #{@clients.size} clients to send a message to")
+            @clients.each do |client|
+                begin
+                    output = message.raw_content.is_a?(Array) ? message.raw_content.join("\n") : message.raw_content + "\n"
+                    client[:connection].puts(output)
+                rescue Object => boom
+                    Logger.warn("Bouncer encountered unexpected error. Disconnecting client. #{boom}")
+                    client[:thread].kill if client[:thread].alive?
+                    @clients.delete(client)
+                end
+            end
+        end
+    end
+    
+    def port(m, params)
+        if(params[:port])
+            if(Models::Config.filter(:name => 'bouncer_port').count > 0)
+                reply m.replyto, "Bouncer port is set to: #{Models::Config.filter(:name => 'bouncer_port').first.value
+            else
+                error m.replyo, 'No port has been set for bouncer'
+            end
+        else
+            parmas[:port].strip!
+            c = Models::Config.find_or_create(:name => 'bouncer_port')
+            c.value = params[:port]
+            c.save
+            information m.replyto, "Bouncer port is not set to: #{params[:port]}"
+        end
+    end
+    
+    def do_service(m, params)
+        begin
+            case params[:action]
+            when 'start'
+                if(listening?)
+                    error m.replyto, 'Bouncer is already running'
+                else
+                    start_listener
+                    information m.replyto, 'Bouncer has been started'
+                end
+            when 'stop'
+                if(listening?)
+                    stop_listener
+                    information m.replyto, 'Bouncer has been stopped'
+                else
+                    error m.replyto, 'Bouncer is not currently running'
+                end
+            when 'restart'
+                stop_listener
+                start_listener
+                information m.replyto, 'Bouncer has been restarted'
+            end
+        rescue Object => boom
+            error m.replyto, "Error was encountered during #{params[:action]} process. (#{boom})"
+        end
+    end
+
+    def disconnect(m, params)
+        unless(@clients.empty?)
+            @clients.each do |client|
+                client[:connection].close unless client[:connection].closed?
+                @clients.delete(client)
+            end
+            information m.replyto, 'All clients have been disconnected'
+        else
+            warning m.replyto, 'No clients are connected to bouncer'
+        end
+    end
+    
+    def status(m, params)
+        warning m.replyto, 'not implemented'
+    end
+
+    private
+    
+    def start_listener
+        port = Models::Config.filter(:name => 'bouncer_port').first
+        raise 'Port has not been set' unless port
+        port = port.value.to_i
+        @socket = OpenSSL::SSL::SSLServer.new(port)
+        @listener = Thread.new do
+            until(@socket.closed?)
+                begin
+                    new_con = @socket.accept_nonblock
+                    add_client(new_con)
+                rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINTR
+                        IO.select([@socket])
+                        retry
+                rescue Object => boom
+                    Logger.warn "Bouncer listener encountered an error: #{boom}"
+                end
+            end
+        end
+    end
+    
+    def add_client
+    end
+
+class Bouncer < ModSpox::Plugin
+    
+    def status(message, params)
+    end
+    
+    private
+    
+    def start_listener
+        port = Config[:bouncer_port]
+        if(port)
+            @socket = TCPServer.new(port)
+            @listener = Thread.new do
+                until(@socket.closed?)
+                    begin
+                        new_con = @socket.accept_nonblock
+                        Logger.info("BOUNCER: New connection established on bouncer")
+                        @clients << {
+                                    :connection => new_con, 
+                                    :thread => Thread.new(new_con) do | con |
+                                        begin
+                                        Logger.info("CONNECTION: #{con}")
+                                        until(con.closed?)
+                                            Logger.info("WAITING FOR STUFF ON :#{con}")
+                                            Kernel.select([con], nil, nil, nil)
+                                            Logger.info("Woken up and ready to read")
+                                            string = con.gets
+                                            Logger.info("BOUNCER GOT MESSAGE: #{string}")
+                                            if(string.empty?)
+                                                raise Exception.new("EMPTY STRING")
+                                            else
+                                                @to_server << {:message => string, :socket => con}
+                                            end
+                                        end
+                                        rescue Object => boom
+                                        Logger.warn("THREAD BOUNCER ERROR: #{boom}")
+                                        end
+                                        end
+                                    }
+                    rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINTR
+                        IO.select([@socket])
+                        retry
+                    end
+                end
+                @listener = nil
+            end
+            start_processor
+        else
+            Logger.warn("Error: Bouncer was not started. Failed to find set port number")
+        end
+    end
+    
+    def stop_listener
+        @socket.close
+        @listener.kill unless @listener.nil?
+        @listener = nil
+        @to_server.clear
+        @processor.kill if !@processor.nil? && @processor.alive?
+        @processor = nil
+    end
+    
+    def start_processor
+        @processor.kill if !@processor.nil? && @processor.alive?
+        @processor = Thread.new do
+        begin
+            while(@listener) do
+                info = @to_server.pop
+                Logger.info("Processing message: #{info[:message]}")
+                if(info[:message] =~ /^USER\s/i)
+                    initialize_connection(info[:socket])
+                else
+                    @pipeline << Messages::Outgoing::Raw.new(info[:message])
+                end
+            end
+        rescue Object => boom
+            Logger.warn("BOUNCER ERROR: #{boom}")
+            unless(@clients.empty?)
+                @clients.each do |socket|
+                    socket[:connection].close
+                    @clients.delete(socket)
+                end
+            end
+        end
+        end
+    end
+    
+    def listening?
+        return !@listener.nil?
+    end
+    
+    def initialize_connection(connection)
+        # send channel info and such to client
+        connection.puts(":localhost 001 #{me.nick} :Welcome to the network #{me.source}\n")
+        Models::Channel.filter(:parked => true).each do |channel|
+            connection.puts(":#{me.source} JOIN :#{channel.name}\n")
+        end
+    end
+    
+end

data/data/mod_spox/extras/Bullshit.rb

@@ -0,0 +1,19 @@
+# ex: set ts=4 et:
+# rip-off of Dack's Web Economy Bullshit Generator (http://dack.com/web/bullshit.html)
+# Copyright 2007 Ryan "pizza" Flynn
+# Ported 2008 spox
+
+class Bullshit < ModSpox::Plugin
+    include ModSpox::Models
+    def initialize(pipeline)
+        super(pipeline)
+        add_sig(:sig => 'bullshit', :method => :bullshit, :desc => 'Web economy bullshit generator')
+        @bs = [[ "aggregate","architect","benchmark","brand","cultivate","deliver","deploy","disintermediate","drive","e-enable","embrace","empower","enable","engage","engineer","enhance","envisioneer","evolve","expedite","exploit","extend","facilitate","generate","grow","harness","implement","incentivize","incubate","innovate","integrate","iterate","leverage","matrix","maximize","mesh","monetize","morph","optimize","orchestrate","productize","recontextualize","redefine","reintermediate","reinvent","repurpose","revolutionize","scale","seize","strategize","streamline","syndicate","synergize","synthesize","target","transform","transition","unleash","utilize","visualize","whiteboard" ],
+            [ "24/365","24/7","B2B","B2C","back-end","best-of-breed","bleeding-edge","bricks-and-clicks","clicks-and-mortar","collaborative","compelling","cross-platform","cross-media","customized","cutting-edge","distributed","dot-com","dynamic","e-business","efficient","end-to-end","enterprise","extensible","frictionless","front-end","global","granular","holistic","impactful","innovative","integrated","interactive","intuitive","killer","leading-edge","magnetic","mission-critical","next-generation","one-to-one","open-source","out-of-the-box","plug-and-play","proactive","real-time","revolutionary","rich","robust","scalable","seamless","sexy","sticky","strategic","synergistic","transparent","turn-key","ubiquitous","user-centric","value-added","vertical","viral","virtual","visionary","web-enabled","wireless","world-class" ],
+            [ "action-items","applications","architectures","bandwidth","channels","communities","content","convergence","deliverables","e-business","e-commerce","e-markets","e-services","e-tailers","experiences","eyeballs","functionalities","infomediaries","infrastructures","initiatives","interfaces","markets","methodologies","metrics","mindshare","models","networks","niches","paradigms","partnerships","platforms","portals","relationships","ROI","synergies","web-readiness","schemas","solutions","supply-chains","systems","technologies","users","vortals","web services" ]]
+    end
+    
+    def bullshit(message, params)
+        reply(message.replyto, @bs[0][rand(@bs[0].length)] + " " + @bs[1][rand(@bs[1].length)] + " " + @bs[2][rand(@bs[2].length)])
+    end
+end

data/data/mod_spox/extras/Bytes.rb

@@ -0,0 +1,11 @@
+class Bytes < ModSpox::Plugin
+    include Models
+    def initialize(args)
+        super
+        add_sig(:sig => 'bytes (\d+)', :method => :convert, :desc => 'Convert bytes to human readable string', :params => [:bytes])
+    end
+    
+    def convert(message, params)
+        reply message.replyto, "#{params[:bytes]} is roughly #{Helpers.format_size(params[:bytes].to_i)}"
+    end
+end