mod_spox 0.2.0 → 0.3.0

data/README

@@ -1,36 +0,0 @@
-mod_spox
-    http://modspox.rubyforge.org
-    Author: spox
-    
-== Description
-
-A Ruby IRC bot
-
-== Usage
-
-Configuration:
-
-mod_spox --config
-
-Running:
-
-mod_spox
-
-== Requirements
-
- * sequel
-  * database driver
- 
-== Optional
-
- * fastthread
- 
-== Install
-
-sudo gem install --include-dependencies mod_spox
-
-== License
-
-mod_spox is licensed under the GPLv3
-
-Copyright (c) 2008 spox <spox@modspox.com>

data/lib/mod_spox/Cache.rb

@@ -1,57 +0,0 @@
-module ModSpox
-    class Cache
-        def initialize(size)
-            @size = size
-            @cache = Hash.new
-            @times = Hash.new
-            @store_lock = Mutex.new
-            @read_lock = Mutex.new
-        end
-        
-        def [](key)
-            if(@cache.has_key?(key.to_sym))
-                @times[key.to_sym] = Time.now
-                return @cache[key.to_sym]
-            else
-                return nil
-            end
-        end
-        
-        def has_key?(key)
-            @read_lock.synchronize do
-                return @cache.has_key?(key.to_sym)
-            end
-        end
-        
-        def []=(key, value)
-            @store_lock.synchronize do
-                if(@cache.size > @size)
-                    del_key = oldest_key
-                    unless(key.nil?)
-                        @cache.delete(del_key)
-                        @times.delete(del_key)
-                    end
-                end
-                @cache[key.to_sym] = value
-                @times[key.to_sym] = Time.now
-            end
-        end
-        
-        def delete(key)
-            @read_lock.synchronize do
-                @cache.delete(key.to_sym) if @cache.has_key?(key.to_sym)
-                @times.delete(key.to_sym) if @times.has_key?(key.to_sym)
-            end
-        end
-        
-        private
-        
-        def oldest_key
-            result = nil
-            @read_lock.synchronize do
-                result = @times.sort{|a,b| a[1] <=> b[1]}[0][0]
-            end
-            return result
-        end
-    end
-end

data/lib/mod_spox/Monitors.rb

@@ -1,84 +0,0 @@
-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 do |t|
-                    begin
-                        t.wakeup
-                    rescue Object => boom
-                        # thread was dead #
-                    end
-                end
-                @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
-                @threads = []
-            end
-            
-            # Stop waiting
-            def wakeup
-                return if @threads.empty?
-                @threads.each do |t|
-                    begin
-                        t.wakeup
-                    rescue Object => boom
-                        # thread was dead #
-                    end
-                end
-                @threads.clear
-            end
-            
-            # Start waiting
-            def wait
-                @threads << Thread.current
-                sleep
-            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
-            
-            # Returns the number of threads currently waiting in this monitor
-            def count
-                @threads.size
-            end
-        
-        end
-    end
-    
-end

data/lib/mod_spox/Pool.rb

@@ -1,164 +0,0 @@
-['mod_spox/Logger',
- 'mod_spox/Exceptions',
- 'timeout',
- 'singleton'].each{|f|require f}
-
-module ModSpox
-
-    class PoolThread
-        def initialize(pool, timeout)
-            @pool = pool
-            @timeout = timeout
-            @kill = false
-            @thread = Thread.new do
-                until @kill do
-                    begin
-                        action = nil
-                        if(Pool.workers > Pool.workers_min)
-                            Timeout::timeout(60) do
-                                action = @pool.queue.pop
-                            end
-                        else
-                            action = @pool.queue.pop
-                        end
-                        run(action) unless action.nil?
-                    rescue Timeout::Error => boom
-                        @kill = true
-                    rescue Object => boom
-                        Logger.warn("Pool thread error: #{boom}")
-                    end
-                end
-                @pool.remove(self)
-            end
-        end
-        
-        private
-        
-        def run(action)
-            begin
-                if(@timeout > 0)
-                    Timeout::timeout(@timeout) do
-                        action.call
-                    end
-                else
-                    action.call
-                end
-            rescue Timeout::Error => boom
-                Logger.warn("Pool worker timed out during execution of action (#{@timeout} sec limit): #{action}")
-            rescue Object => boom
-                Logger.warn("Pool worker caught an unknown exception: #{boom}")
-            end
-        end
-    end
-
-    # The Pool class is used to reduce thread creation. It provides
-    # an easy way to process many actions in an asynchronous manner.
-    class Pool
-    
-        include Singleton
-
-        # Add an action to the pool to be processed
-        def Pool.<<(action)
-            Pool.instance.add(action)
-        end
-        
-        # Alias of Pool.<<(action)
-        def Pool.queue(action)
-            Pool << action
-        end
-        
-        def Pool.workers
-            Pool.instance.threads.size
-        end
-        
-        def Pool.workers_min
-            return Pool.instance.min
-        end
-        
-        def Pool.workers_max
-            return Pool.instance.max
-        end
-        
-        def remove(pt)
-            @threads.delete(pt)
-            Logger.info("Pool thread has been removed: #{pt}")
-        end
-        
-        def add(action)
-            @queue << action
-            create_pool_thread if @queue.size > @min
-        end
-        
-        # Return maximum number of seconds actions are allowed to process
-        def Pool.worker_timeout
-            Pool.instance.timeout
-        end
-
-        # time:: number of seconds actions are allowed
-        # Set number of seconds actions are allowed to work
-        def Pool.worker_timeout=(time)
-            Pool.instance.timeout = time
-        end
-
-        # Set maximum number of workers to process tasks
-        def Pool.workers_max=(max)
-            Pool.instance.workers_max = max
-        end
-        
-        # Not currently implemented
-        def Pool.workers_min=(min)
-            Pool.instance.workers_min = min
-        end
-        
-        attr_reader :threads
-        attr_reader :queue
-        attr_reader :min
-        attr_reader :max
-        attr_reader :timeout
-    
-        def initialize
-            @queue = Queue.new
-            @threads = []
-            @lock = Mutex.new
-            @timeout = get_value('pool_timeout', 0).to_i
-            @max = Database.type != :pgsql ? 1 : get_value('pool_workers_max', 7).to_i
-            @min = Database.type != :pgsql ? 1 : get_value('pool_workers_min', 5).to_i
-            @min.times{create_pool_thread}
-        end
-        
-        def create_pool_thread(force=false)
-            return nil unless @threads.size < @max || force
-            pt = PoolThread.new(self, @timeout)
-            @threads << pt
-            return pt
-        end
-        
-        def get_value(n, default)
-            m = Models::Config.filter(:name => n).first
-            return m.nil? ? default : m.value
-        end
-        
-        def set_value(n, v)
-            m = Models::Config.find_or_create(:name => n)
-            m.value = v
-            m.save
-        end
-        
-        def timeout=(v)
-            set_value('pool_timeout', v.to_i)
-            @timeout = v.to_i
-        end
-        
-        def workers_max=(v)
-            set_value('pool_workers_max', v.to_i)
-            @max = v.to_i
-        end
-        
-        def workers_min=(v)
-            set_value('pool_workers_min', v.to_i)
-            @min = v.to_i
-        end
-
-    end
-
-end

data/lib/mod_spox/models/AuthGroup.rb

@@ -1,16 +0,0 @@
-module ModSpox
-    module Models
-        class AuthGroup < Sequel::Model
-
-            set_primary_key [:group_id, :auth_id]
-
-            def auth
-                Auth[auth_id]
-            end
-
-            def group
-                Group[group_id]
-            end
-        end
-    end
-end

data/lib/mod_spox/models/ChannelMode.rb

@@ -1,14 +0,0 @@
-module ModSpox
-    module Models
-        # Attribute provided by model:
-        # mode:: mode that is set
-        class ChannelMode < Sequel::Model
-
-            # Channel this mode is associated to
-            def channel
-                Channel[channel_id]
-            end
-
-        end
-    end
-end

data/lib/mod_spox/models/NickChannel.rb

@@ -1,45 +0,0 @@
-module ModSpox
-    module Models
-        # This model is for internal use only to provide a
-        # proper relation between Nick and Channel
-        class NickChannel < Sequel::Model
-
-            include Models
-
-            set_primary_key [:nick_id, :channel_id]
-
-            after_save do
-                c = Channel[channel_id]
-                n = Nick[nick_id]
-                n.visible = true
-                n.save
-                c.parked = true
-                c.save
-            end
-
-            after_destroy do
-                c = Channel[channel_id]
-                n = Nick[nick_id]
-                if(n.channels.size < 1)
-                    n.visible = false
-                    n.save
-                    NickMode.filter(:nick_id => nick_id).each{|n|n.destroy}
-                end
-                if(c.nicks.size < 1)
-                    c.parked = false
-                    c.save
-                    NickMode.filter(:channel_id => channel_id).each{|n|n.destroy}
-                    ChannelMode.filter(:channel_id => channel_id).each{|n|n.destroy}
-                end
-            end
-
-            def nick
-                Nick[nick_id]
-            end
-
-            def channel
-                Channel[channel_id]
-            end
-        end
-    end
-end

data/lib/mod_spox/models/NickGroup.rb

@@ -1,16 +0,0 @@
-module ModSpox
-    module Models
-        class NickGroup < Sequel::Model
-
-            set_primary_key [:nick_id, :group_id]
-
-            def nick
-                Nick[nick_id]
-            end
-
-            def group
-                Group[group_id]
-            end
-        end
-    end
-end