woolen_common 0.0.1

data/lib/woolen_common/splib/Constants.rb

@@ -0,0 +1,44 @@
+module Splib
+    # c:: constant name (String)
+    # things:: Array of Object/Module constants to look in
+    # Finds a constant if it exists
+    # Example:: Foo::Bar 
+    # Returns nil if nothing found
+    def self.find_const(c, things=[])
+        raise ArgumentError.new('Exepcting an array') unless things.is_a?(Array)
+        const = nil
+        (things + [Object]).each do |base|
+            begin
+                c.split('::').each do |part|
+                    const = const.nil? ? base.const_get(part) : const.const_get(part)
+                end
+            rescue NameError
+                const = nil
+            end
+            break unless const.nil?
+        end
+        const
+    end
+
+    # a:: an object
+    # b:: constant or string
+    # Returns true of a is a type of b. b can be given as a String
+    # to allow for matching of types contained within a module or
+    # for types that may not be loaded
+    def self.type_of?(a, b)
+        case b
+        when String
+            if(a.class.to_s.slice(0).chr == '#')
+                name = a.class.to_s
+                return name.slice(name.index('::')+2, name.length) == b
+            else
+                const = self.find_const(b)
+                return const.nil? ? false : a.is_a?(const)
+            end
+        when Class
+            return a.is_a?(b)
+        else
+            raise ArgumentError.new('Comparision type must be a string or constant')
+        end
+    end
+end

data/lib/woolen_common/splib/Conversions.rb

@@ -0,0 +1,47 @@
+module Splib
+    # secs:: number of seconds
+    # Converts seconds into a human readable string (This is an estimate
+    # and does not account for leaps)
+    def self.format_seconds(secs)
+        arg = [{:year => 31536000},
+                {:month => 2678400},
+                {:week => 604800},
+                {:day => 86400},
+                {:hour => 3600},
+                {:minute => 60},
+                {:second => 1}]
+        res = ''
+        arg.each do |val|
+            val.each_pair do |k,v|
+                z = (secs / v).to_i
+                next unless z > 0
+                res += " #{z} #{k}#{z == 1 ? '':'s'}"
+                secs = secs % v
+            end
+        end
+        res = '0 seconds' if res.empty?
+        return res.strip
+    end
+
+    # bytes:: number of bytes
+    # Converts bytes into easy human readable form
+    # O(1) version by Ryan "pizza_milkshake" Flynn
+    Suff = [
+    "",       # 1024^0
+    "Kilo",   # 1024^1
+    "Mega",   # 1024^2
+    "Giga",   # 1024^3
+    "Tera",   # 1024^4
+    "Peta",   # 1024^5
+    "Exa",    # 1024^6
+    "Zetta",  # 1024^7
+    "Yotta"   # 1024^8
+    ]
+    def self.format_size(bytes)
+        return "0 bytes" if bytes == 0
+        mag = (Math.log(bytes) / Math.log(1024)).floor
+        mag = [ Suff.length - 1, mag ].min
+        val = bytes.to_f / (1024 ** mag)
+        ("%.2f %sbyte%s" % [ val, Suff[mag], val == 1 ? "" : "s" ]).strip
+    end
+end

data/lib/woolen_common/splib/Exec.rb

@@ -0,0 +1,132 @@
+require 'timeout'
+
+module Splib
+
+    @@processes = []
+    @@owner ||= Thread.current
+    Kernel.at_exit do
+        if(Thread.current == @@owner)
+            @@processes.each{|pro| Process.kill('KILL', pro.pid) }
+        end
+    end
+
+    # Returns current array of running Processes
+    def self.running_procs
+        @@processes
+    end
+    # command:: command string to execute
+    # timeout:: length of time to execute
+    # maxbytes:: maximum number return bytes allowed
+    # Execute system command. This is a wrapper method
+    # that will redirect to the proper command
+    def self.exec(*args)
+        if(RUBY_PLATFORM == 'java')
+            thread_exec(*args)
+        else
+            standard_exec(*args)
+        end
+    end
+    
+    # command:: command to execute
+    # timeout:: maximum number of seconds to run
+    # maxbytes:: maximum number of result bytes to accept
+    # priority:: set priority of the process
+    # Execute a system command (use with care)
+    # This is the normal exec command that is used
+    def self.standard_exec(command, timeout=10, maxbytes=500, priority=nil)
+        timeout = timeout.to_i
+        maxbytes = maxbytes.to_i
+        priority = priority.to_i
+        output = []
+        pro = nil
+        begin
+            if(timeout > 0)
+                Timeout::timeout(timeout) do
+                    pro = IO.popen(command)
+                    @@processes << pro
+                    if(priority > 0)
+                        Process.setpriority(Process::PRIO_PROCESS, pro.pid, priority)
+                    end
+                    until(pro.closed? || pro.eof?)
+                        output << pro.getc.chr
+                        if(maxbytes > 0 && output.size > maxbytes)
+                            raise IOError.new("Maximum allowed output bytes exceeded. (#{maxbytes} bytes)")
+                        end
+                    end
+                end
+            else
+                pro = IO.popen(command)
+                @@processes << pro
+                until(pro.closed? || pro.eof?)
+                    output << pro.getc.chr
+                    if(maxbytes > 0 && output.size > maxbytes)
+                        raise IOError.new("Maximum allowed output bytes exceeded. (#{maxbytes} bytes)")
+                    end
+                end
+            end
+            output = output.join('')
+        ensure
+            Process.kill('KILL', pro.pid) if Process.waitpid2(pro.pid, Process::WNOHANG).nil? # make sure the process is dead
+            @@processes.delete(pro)
+        end
+        return output
+    end
+    # Used for the thread_exec method to notify of completion
+    class Complete < StandardError
+    end
+
+    # command:: command to execute
+    # timeout:: maximum number of seconds to run
+    # maxbytes:: maximum number of result bytes to accept
+    # priority:: set priority of the process
+    # Execute a system command (use with care)
+    # This is the threaded exec command that is generally used
+    # with JRuby. The regular timeout does not work when executing
+    # a process, so we do it in a separate thread and sleep the main
+    # thread until the timeout is reached.
+    def self.thread_exec(command, timeout=10, maxbytes=500)
+        timeout = timeout.to_i
+        maxbytes = maxbytes.to_i
+        priority = priority.to_i
+        current = Thread.current
+        output = []
+        pro = nil
+        thread = Thread.new do
+            boom = Complete.new
+            begin
+                pro = IO.popen(command)
+                @@processes << pro
+                if(priority > 0)
+                    Process.setpriority(Process::PRIO_PROCESS, pro.pid, priority)
+                end
+                until(pro.closed? || pro.eof?)
+                    output << pro.getc.chr
+                    if(maxbytes > 0 && output.size > maxbytes)
+                        raise IOError.new("Maximum allowed output bytes exceeded. (#{maxbytes} bytes)")
+                    end
+                end
+            rescue Exception => boom
+                # just want it set
+            end
+            current.raise boom unless boom.is_a?(Timeout::Error)
+        end
+        begin
+            begin
+                if(timeout > 0)
+                    thread.join(timeout)
+                    thread.raise Timeout::Error.new
+                    raise Timeout::Error.new
+                else
+                    thread.join
+                end
+                output.join('')
+            rescue Complete
+                # ignore this exception
+            end
+        ensure
+            Process.kill('KILL', pro.pid) unless pro.nil?
+            @@processes.delete(pro)
+        end
+        output.join('')
+    end
+end

data/lib/woolen_common/splib/Float.rb

@@ -0,0 +1,13 @@
+module Splib
+    # While not a big fan of monkeypatching, I want to be
+    # lazy getting to this
+    class ::Float
+        def within_delta?(args={})
+            raise ArgumentError.new('Missing required argument: :expected') unless args[:expected]
+            raise ArgumentError.new('Missing required argument: :delta') unless args[:delta]
+            e = args[:expected].to_f
+            d = args[:delta].to_f
+            self.between?(e-d, e+d)
+        end
+    end
+end

data/lib/woolen_common/splib/HumanIdealRandomIterator.rb

@@ -0,0 +1,40 @@
+module Splib
+    # IdealHumanRandomIterator - select "random" members of a population, favoring
+    # those least-recently selected, to appease silly humans who hate repeats
+    #
+    # Abstract:
+    # given a decently-sized set of items (say, 100 famous quotes), an
+    # average persons's idea of N "random" entries is not actually random.
+    # people don't want items to appear twice in a row, or too frequently
+    # (even though true randomness means this is just as likely as any other order).
+    #
+    # instead, design a scheme whereby LRU items are weighted more heavily,
+    # to "encourage" subsequent selections to not repeat.
+    #
+    # Author: Ryan "pizza_" Flynn
+    # - pulled from the algodict project
+    # - - http://github.com/pizza/algodict
+    class IdealHumanRandomIterator
+        
+        def initialize(list)
+            raise ArgumentError.new("Array type required") unless list.is_a?(Array)
+            @items = list
+        end
+        
+        # Given length L, generate a random number in the range [0,len-1), heavily
+        # weighted towards the low end.
+        def self.nexti(len)
+            len += 1 if len % 2 == 1
+            index = len > 2 ? rand(len/2) : 0
+            return index
+        end
+        
+        # return a psuedo-random member of items. subsequent calls should never
+        # return the same item.
+        def next()
+            index = IdealHumanRandomIterator.nexti(@items.length)
+            @items.push @items.delete_at(index)
+            return @items.last
+        end
+    end
+end

data/lib/woolen_common/splib/Monitor.rb

@@ -0,0 +1,214 @@
+require 'thread'
+
+module Splib
+    Splib.load :Sleep
+    # Basic exception to wakeup a monitor timer
+    class Wakeup < Exception
+    end
+    class Monitor
+        # Create a new Monitor
+        def initialize
+            @threads = []
+            @locks = []
+            @lock_owner = nil
+            @timers = {}
+            @timer = start_timer
+            @stop = false
+            Kernel.at_exit do
+                if(@timer)
+                    @stop = true
+                    @timer.raise Wakeup.new
+                end
+            end
+        end
+
+        # timeout:: Wait for given amount of time
+        # Park a thread here
+        def wait(timeout=nil)
+            raise 'This thread is already a registered sleeper' if @threads.include?(Thread.current)
+            Thread.exclusive{ @threads << Thread.current }
+            if(timeout)
+                timeout = timeout.to_f
+                Thread.exclusive{ @timers[Thread.current] = timeout }
+                @timer.raise Wakeup.new
+            end
+            Thread.stop
+            Thread.exclusive{ @threads.delete(Thread.current) }
+            if(timeout && @timers.has_key?(Thread.current))
+                Thread.exclusive{ @timers.delete(Thread.current) }
+                @timer.raise Wakeup.new
+            end
+            true
+        end
+        # Park thread while block is true
+        def wait_while
+            while yield
+                wait
+            end
+        end
+        # Park thread until block is true
+        def wait_until
+            until yield
+                wait
+            end
+        end
+        # Wake up earliest thread
+        def signal
+            synchronize do
+                while(t = @threads.shift)
+                    if(t && t.alive? && t.stop?)
+                        t.wakeup
+                        break
+                    else
+                        next
+                    end
+                end
+            end
+        end
+        # Wake up all threads
+        def broadcast
+            synchronize do
+                @threads.dup.each do |t|
+                    t.wakeup if t.alive? && t.stop?
+                end
+            end
+        end
+        # Number of threads waiting
+        def waiters
+            @threads.size
+        end
+        # Lock the monitor
+        def lock
+            Thread.exclusive{ do_lock }
+            until(owner?(Thread.current)) do
+                Thread.stop
+            end
+        end
+        # Unlock the monitor
+        def unlock
+            do_unlock
+        end
+        # Attempt to lock. Returns true if lock is aquired and false if not.
+        def try_lock
+            locked = false
+            Thread.exclusive do
+                clean
+                unless(locked?(false))
+                    do_lock
+                    locked = true
+                else
+                    locked = owner?(Thread.current)
+                end
+            end
+            locked
+        end
+        # cln:: Clean dead threads
+        # Is monitor locked
+        def locked?(cln=true)
+            Thread.exclusive{clean} if cln
+            @locks.size > 0 || @lock_owner
+        end
+        # Lock the monitor, execute block and unlock the monitor
+        def synchronize
+            result = nil
+            lock
+            result = yield
+            do_unlock
+            result
+        end
+
+        private
+
+
+        # This is a simple helper method to help keep threads from ending
+        # up stuck waiting for a lock when a thread locks the monitor and
+        # then decides to die without unlocking. It is only called when
+        # new locks are attempted or a check is made if the monitor is
+        # currently locked.
+        def clean
+            @locks.delete_if{|t|!t.alive?}
+            if(@lock_owner && !@lock_owner.alive?)
+                @lock_owner = @locks.empty? ? nil : @locks.shift
+                @lock_owner.wakeup if @lock_owner && !owner?(Thread.current)
+            end
+        end
+
+        # Check if the givin thread is the current owner
+        def owner?(t)
+            @lock_owner == t
+        end
+
+        # Aquire monitor lock or be queued for lock
+        # NOTE: To make this method more generic and useful, it does
+        # not perform a Thread.exclusive, and as such this method should
+        # only be called from within a Thread.exclusive{}
+        def do_lock
+            clean
+            if(@lock_owner)
+                if(owner?(Thread.current))
+                    @locks.unshift(Thread.current)
+                else
+                    @locks << Thread.current
+                end
+            else
+                @lock_owner = Thread.current
+            end
+            true
+        end
+
+        # Unlock the monitor
+        def do_unlock
+            unless(owner?(Thread.current))
+                raise ThreadError.new("Thread #{Thread.current} is not the current owner: #{@lock_owner}")
+            end
+            Thread.exclusive do
+                @locks.delete_if{|t|!t.alive?}
+                unless(@locks.empty?)
+                    old_owner = @lock_owner
+                    @lock_owner = @locks.shift
+                    @lock_owner.wakeup unless old_owner == @lock_owner
+                else
+                    @lock_owner = nil
+                end
+            end
+        end
+
+        # Starts the timer for waiting threads with a timeout
+        def start_timer
+            @timer = Thread.new do
+                begin
+                    until(@stop) do
+                        cur = []
+                        t = 0
+                        Thread.exclusive do
+                            t = @timers.values.min
+                            cur = @timers.dup
+                        end
+                        t = 0 if !t.nil? && t < 0
+                        a = 0
+                        begin
+                            a = Splib.sleep(t)
+                        rescue Wakeup
+                            # do nothing of importance
+                        ensure
+                            next if t.nil?
+                            Thread.exclusive do
+                                cur.each_pair do |thread, value|
+                                    value -= a
+                                    if(value <= 0)
+                                        thread.wakeup
+                                        @timers.delete(thread)
+                                    else
+                                        @timers[thread] = value
+                                    end
+                                end
+                            end
+                        end
+                    end
+                rescue
+                    retry
+                end
+            end
+        end
+    end
+end