add dispatcher and math

2 files changed, 393 insertions, 0 deletions

diff --git a/lib/ayk/dispatcher.rb b/lib/ayk/dispatcher.rb
new file mode 100644
index 0000000..2a3d619
--- /dev/null
+++ b/lib/ayk/dispatcher.rb
@@ -0,0 +1,282 @@
+#! /usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+#----------------------------------------------------------------------------
+#
+# File     : dispatcher.rb
+#
+# Author   : Jérémy Zurcher <jeremy@asynk.ch>
+#
+# Date     : 16/10/07 
+#
+# License  :
+#   Permission is hereby granted, free of charge, to any person obtaining
+#   a copy of this software and associated documentation files (the
+#   "Software"), to deal in the Software without restriction, including
+#   without limitation the rights to use, copy, modify, merge, publish,
+#   distribute, sublicense, and/or sell copies of the Software, and to
+#   permit persons to whom the Software is furnished to do so, subject to
+#   the following conditions:
+#
+#   The above copyright notice and this permission notice shall be
+#   included in all copies or substantial portions of the Software.
+#
+#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+#   LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+#   OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+#   WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Purpose  : messages management on a per channel basis with level thresholds, rotations
+#
+#----------------------------------------------------------------------------
+
+
+#----------------------------------------------------------------------------
+# messages management on a per channel basis with level thresholds, rotations
+module Dispatcher
+
+    module Level
+        OFF = 0
+        ON = 1
+        DBG1 = 2
+        DBG2 = 3
+        DBG3 = 4
+        def format_sev( sev ) ['<  OFF >','<   ON >','< DBG1 >','< DBG2 >','< DBG3 >'][sev] || ' <UNKNOWN>' end
+    end
+
+    # this class is in charge of dispatching an event to all it's registered sinks
+    class Channel
+        attr_reader :id, :sinks
+        attr_accessor :level
+        # +id+ is an id
+        # +level+ is a value used to except or reject messages with level, see Logger for level levels
+        def initialize( id, level=Level::ON )
+            @id = id
+            @level = level
+            @sinks = []
+        end
+        # register sink as a sink
+        def register( sink ) @sinks<<sink if not @sinks.include? sink end
+        # unregister sink
+        def unregister( sink ) @sinks.delete sink end
+        # remove all sinks
+        def clear; @sinks.clear end
+        # dispatch +data+ to all of it's sinks if messages's level+ is lower enough
+        def dispatch( data, level )
+            return if level>@level
+            @sinks.each{ |s|
+                next if level>s.level
+                if s.respond_to? :handle_rot
+                    s.handle_rot data, level
+                else
+                    s.handle data, level
+                end
+            }
+        end
+        # pretty output
+        def to_s
+            ret = "#{self.class} #{@id}\n   level : #{@level}\n   sinks :"
+            @sinks.each{ |s| ret += "\n\t#{s.id}" }
+            ret
+        end
+    end
+
+    # this the base class for simple sinks
+    # you should inherit from Sink and implement +handle+ method
+    class Sink
+        attr_reader :id, :channels
+        attr_accessor :level
+        # +id+ is only an id
+        # +channels+ is a list of channels id which this instance belongs to
+        # +level+
+        def initialize( id, channels, level=Level::INFO )
+            # TODO raise if not channels.respond_to? :each
+            @id = id
+            @channels = channels
+            @level = level
+        end
+        # pretty output
+        def to_s 
+            ret = "#{self.class} #{@id}\n   rotation : #{@rotation_scheme.nil? ? 'never' : @rotation_scheme.to_s + " next on #{@next_rotation}" }\n   channels :"
+            @channels.each{ |c| ret +="\n\t#{c} " }
+            ret
+        end
+        # TO BE IMPLEMENTED, should handle data
+        def handle( data, level ); raise NotImplementedError.new end
+    end
+
+    # this the base class for sinks with time based rotation capabilities
+    # you should inherit from SinkRotate and implement +handle+ and +rotate+ methods
+    class SinkRotate < Sink
+        attr_reader :rotation_scheme, :next_rotation
+        # +id+ is only an id
+        # +channels+ is a list of channels id which this instance belongs to
+        # +rotation_scheme+ is one of : +nil, :hourly, :daily, :weekly, :monthly+
+        def initialize( id, channels, rotation_scheme, level=Level::ON )
+            super( id, channels, level )
+            @rotation_scheme = rotation_scheme
+            @next_rotation = compute_next_rotation
+        end
+        # call rotate if data respond_to :time and time is >= then next_rotation
+        def handle_rot( data, level )
+            if data.respond_to? :time and data.time >= @next_rotation
+                rotate @next_rotation
+                @next_rotation = compute_next_rotation data.time
+            end
+            handle data, level
+        end
+        # return computed next rotation time
+        #   +t+ base computation time for simulation purpose
+        def compute_next_rotation( t=Time.now )
+            case @rotation_scheme
+            when :hourly then
+                t += 3600
+                Time.mktime(t.year, t.month, t.mday, t.hour, 0, 0)
+            when :daily then
+                t += 86400 # 24*3600
+                Time.mktime(t.year, t.month, t.mday, 0, 0, 0)
+            when :weekly then
+                t += (8-t.wday)*86400 # 24*3600 # monday 00:00:00
+                Time.mktime(t.year, t.month, t.mday, 0, 0, 0)
+            when :monthly then
+                if t.month <12
+                    Time.mktime(t.year, t.month+1, 1, 0, 0, 0)
+                else
+                    Time.mktime(t.year+1, 1, 1, 0, 0, 0)
+                end
+            else
+                t
+            end
+        end
+        # TO BE IMPLEMENTED, should handle rotation time
+        def rotate( t ); raise NotImplementedError.new end
+    end
+
+    #
+    class Dispatcher
+        #
+        def initialize;
+            @sinks = []
+            @channels = {}
+        end
+        # clear channels and sinks
+        def clear
+            @channels.clear
+            @sinks.clear
+        end
+        # send +data+ in all channels
+        def send_all( data, level=Level::ON )
+            @channels.each{ |k,c| c.dispatch data, level }
+        end
+        # send +data+ in +channels+
+        def send( data, channels, level=Level::ON )
+            level = data.level if data.respond_to? :level
+            channels.each{ |c| @channels[c].dispatch data, level if @channels.has_key? c }
+        end
+        # find +id+ in +what+
+        def find( what, id )
+            return @channels[id] if what==:channel
+            return @sinks.find{ |s| s.id==id } if what==:sink
+            nil
+        end
+        # return sink +s_id+ if exists
+
+        # pretty output
+        def to_s
+            ret = "####{self.class}"
+            ret +="\n\n ## Channels :"
+            @channels.each{ |i,c| ret += "\n  #{c.to_s}" }
+            ret +="\n\n ## Sinks :"
+            @sinks.each{ |s| ret += "\n  #{s.to_s}" }
+            ret
+        end
+        # set a +channel+ and update it's sinks if exists
+        def register_channel( channel )
+            return if @channels.has_key? channel.id
+            @channels[channel.id] = channel
+            @sinks.each{ |s| s.channels.each{ |c| channel.register s if c == channel.id } }
+        end
+        # remove +channel+ from channels list
+        def unregister_channel( channel )
+            return if not @channels.has_key? channel.id
+            @sinks.each{ |s| s.channels.each{ |c| channel.unregister s if c == channel.id } }
+            @channels.delete channel.id
+        end
+        # register +sink+ and update +channels+
+        def register_sink( sink )
+            return if @sinks.include? sink
+            @sinks<<sink
+            sink.channels.each{ |c| @channels[c].register( sink ) if @channels.has_key? c }
+        end
+        # unregister +sink+
+        def unregister_sink( sink )
+            return if not @sinks.include? sink
+            sink.channels.each{ |c| @channels[c].unregister( sink ) if @channels.has_key? c }
+            @sinks.delete sink
+        end
+    end
+
+    # TEST classes
+
+    # a sink which call a hook when activated
+    class CallbackSink < Sink
+        def initialize( id, channels, level=Level::ON, &blk )
+            super( id, channels, level )
+            @blk = blk
+        end
+        # output this event and flush the io
+        def handle( data, level ); @blk.call( data, level ) end
+    end
+
+    # an IO based sink for STDOUT and STDERR
+    class IOSink < Sink
+        # +id+ is the channel id
+        # +io+ is an IO object
+        # +channels+ is a list of channels id
+        def initialize( id, io, channels, level=Level::ON, &blk)
+            super( id, channels, level )
+            @io = io
+            @blk = blk
+        end
+        # output this event and flush the io
+        def handle( data, level ); @io << (@blk.nil? ? data.to_s : @blk.call(data,level) ); @io.flush end
+    end
+
+    # simple file sink
+    class FileSink < Sink
+        # +id+ is the channel id
+        # +fname+ is the file path
+        # +channels+ is a list of channels id
+        def initialize( id, fname, channels, level=Level::ON, &blk )
+            super( id, channels, level )
+            @fname = fname
+            @blk = blk
+        end
+        attr_accessor :fname
+        # output this event and flush the fname
+        def handle( data, level ) open( @fname, 'a') { |f| f << ( @blk.nil? ? data.to_s : @blk.call(data,level) ) } end
+    end
+
+    # a file path based sink with rotation implemented
+    class FileSinkRotate < SinkRotate
+        # +id+ is the channel id
+        # +basename+ is the file path in a strftime like format
+        # +channels+ is a list of channels id
+        # +rotation+ is one of : +nil, :hourly, :daily, :weekly, :monthly+
+        def initialize( id, basename, channels, rotation, level=Level::ON, &blk )
+            super( id, channels, rotation, level )
+            @basename = basename
+            rotate Time.now
+            @blk = blk
+        end
+        attr_accessor :fname
+        # output this event and flush the fname
+        def rotate( t ) @fname = t.strftime( @basename ) end
+        # output this event and flush the fname
+        def handle( data, level ) open( @fname, 'a') { |f| f << ( @blk.nil? ? data.to_s : @blk.call(data,level) ) } end
+    end
+end
+
diff --git a/lib/ayk/math.rb b/lib/ayk/math.rb
new file mode 100644
index 0000000..90a3b3a
--- /dev/null
+++ b/lib/ayk/math.rb
@@ -0,0 +1,111 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+
+#----------------------------------------------------------------------------
+#
+# File     : math.rb
+# Author   : Jérémy Zurcher <jeremy@asynk.ch>
+# Date     : 14/09/09 
+# License  :
+#
+#   Copyright (c) 2009 Jérémy Zurcher
+#
+#   Permission is hereby granted, free of charge, to any person obtaining
+#   a copy of this software and associated documentation files (the
+#   "Software"), to deal in the Software without restriction, including
+#   without limitation the rights to use, copy, modify, merge, publish,
+#   distribute, sublicense, and/or sell copies of the Software, and to
+#   permit persons to whom the Software is furnished to do so, subject to
+#   the following conditions:
+#
+#   The above copyright notice and this permission notice shall be
+#   included in all copies or substantial portions of the Software.
+#
+#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+#   LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+#   OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+#   WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+#----------------------------------------------------------------------------
+#
+#def prime?
+#    ('1'*self) !~ /^1?$|^(11+?)\1+$/
+#end
+#def Math.gcd(x,y)
+#    /^(1+)\1*=\1+$/.match('1'*x+'='+'1'*y)[1].length
+#end
+#
+# generate prime numbers < n
+def Math.sieve n
+    sieve = [nil, nil] + (2 .. n).to_a
+    (2 .. Math.sqrt(n)).each do |i|
+        next unless sieve[i]
+        (i*i).step(n, i) do |j|
+            sieve[j] = nil
+        end
+    end
+    sieve.compact
+end
+#
+# return greater common divisor
+def Math.gcd x, y
+    y,x=x,y if x<y
+    while y > 0 
+        r = x % y 
+        x = y
+        y = r
+    end
+    return x
+end
+#
+# return true if is a prime number
+def Math.prime? x
+#    return false if x <0
+    if x==3
+        return true
+    elsif x % 2 == 0
+        return false
+    elsif x % 3 == 0
+        return false
+    else
+        r = (x**0.5).floor
+        d = 5
+        while d<r
+            if x % d == 0
+                return false
+            end
+            if x % (d + 2) == 0
+                return false
+            end
+            d+=6
+        end
+        return true
+    end
+end
+#
+# return a bits long prime number
+def Math.prime bits
+    bytes_n,bits_n = bits.divmod 8
+    bytes = []
+    begin
+        # n = ( (rand()*Time.now.to_f).to_i & 0xff) | 0x80 random char better than rand(255) + 1 ?????
+        # rand currently uses a modified Mersenne Twister with a period of 2**19937-1
+        srand()
+        bytes.clear
+        bytes_n.times do
+            bytes << rand(255)+1
+        end
+        bytes << ( ((rand()*Time.now.to_f).to_i & 0xFF | 0x80) >> (8 - bits_n) )
+        n = Bignum.from_bytes( bytes.inject(''){|s,b|s+=b.chr} )
+        puts n
+        n+= 1 if n%2 == 0
+        while not Math::prime? n
+            n += 2
+        end
+    end while n.bits != bits
+    n
+end
+#