IOWA 1.0.0

data/src/iowa/Logger.rb

@@ -0,0 +1,74 @@
+
+# Iowa::Logger is the base class that IOWA loggers all inherit from.
+#
+
+module Iowa
+  class Logger
+
+    Levels = {:debug => true, :info => true, :warning => true, :error => true, :fatal => true}
+
+    @store = {}
+
+    def self.[](val)
+      @store[val]
+    end
+
+    def self.[]=(key,val)
+      @store[key] = val
+    end
+
+    def initialize(*args)
+      configure
+      open
+    end
+
+    def configure
+    end
+
+    def open
+    end
+
+    def level
+      @logger.level
+    end
+
+    def level=(lvl)
+      l = normalize_level(lvl)
+      @level = l
+      @logger.level = l
+    end
+
+    def normalize_level(lvl)
+      l = lvl.to_s.downcase.intern
+      l = :debug unless Levels.has_key?(l)
+      l
+    end
+
+    def debug(msg)
+      @logger.debug msg
+    end
+
+    def info(msg)
+      @logger.info msg
+    end
+
+    def warn(msg)
+      @logger.warn msg
+    end
+
+    def error(msg)
+      @logger.error msg
+    end
+
+    def fatal(msg)
+      @logger.fatal msg
+    end
+
+    def close
+      @logger.close
+    end
+
+    def flush; end
+
+  end
+end

data/src/iowa/Monkey.rb

@@ -0,0 +1,20 @@
+module Iowa
+  # Monkey see, Monkey do.
+  #
+  # That is, use this class to deal with @ usage in templates that doesn't match any existing method.
+  #
+  class Monkey
+    def initialize(val = '')
+      @val = val
+    end
+
+    def method_missing(meth)
+      Monkey.new("#{@val}.#{meth}")
+    end
+
+    def to_s
+      @val
+    end
+  end
+end
+

data/src/iowa/Mutex.rb

@@ -0,0 +1,142 @@
+module Iowa
+
+	# Iowa::Mutex is a slight modification of the standard Ruby Mutex class.
+	# This class changes the array operations used to manage the queue of
+	# threads waiting for a lock in order to get better memory management
+	# behavior from the array.  This mutex will also not block if the thread
+	# holding a lock on a mutex calls lock on that mutex again.  If nested
+	# locking occurs, the locks must be matched by an equal number of unlocks
+	# before the mutex will actually be unlocked.
+
+	class Mutex
+		
+		# Creates a new Mutex.
+		
+		def initialize
+			@waiting = []
+			@locked = false;
+			@nested_locks = 0
+			@waiting.taint		# enable tainted comunication
+			self.taint
+		end
+
+		
+		# Returns the thread that holds the lock or +false+ if the mutex is not locked.
+		
+		def locked?
+			@locked
+		end
+
+		
+		# Attempts to obtain the lock and returns immediately. Returns +true+ if the
+		# lock was granted.
+		
+		def try_lock
+			@nested_locks += 1 and return true if @locked == Thread.current
+			result = false
+			Thread.critical = true
+			unless @locked
+				@locked = Thread.current
+				result = true
+			end
+			Thread.critical = false
+			result
+		end
+
+
+		# Attempts to obtain a lock on the mutex.  Block if a lock can not be
+		# obtained immediately and waits until the lock can be obtained.
+		# If this thread already holds this lock, returns immediately.
+		# Returns the mutex.
+
+		def lock
+			if @locked == Thread.current
+				@nested_locks += 1
+			else
+				while (Thread.critical = true; @locked)
+					@waiting.unshift Thread.current
+					Thread.stop
+				end
+				@locked = Thread.current
+				Thread.critical = false
+			end
+			self
+		end
+
+
+		# Releases this thread's lock on the mutex and wakes the next thread
+		# waiting for the lock, if any.
+		
+		def unlock
+			return unless @locked
+			if @nested_locks > 0
+				@nested_locks -= 1
+			else
+				Thread.critical = true
+				@locked = false
+				begin
+					t = @waiting.pop
+					t.wakeup if t
+				rescue ThreadError
+					retry
+				end
+				Thread.critical = false
+				begin
+					t.run if t
+				rescue ThreadError
+				end
+			end
+			self
+		end
+
+		
+		# If the mutex is locked, unlocks the mutex, wakes one waiting thread, and
+		# yields in a critical section.
+		
+		def exclusive_unlock
+			return unless @locked
+			if @nested_locks > 0
+				@nested_locks -= 1
+			else
+				Thread.exclusive do
+					@locked = false
+					begin
+						t = @waiting.pop
+						t.wakeup if t
+					rescue ThreadError
+						retry
+					end
+					yield
+				end
+			end
+			self
+		end
+
+  
+		# Obtains a lock, runs the block, and releases the lock when the block
+		# completes.  See the example under Mutex.
+  
+		def synchronize
+			lock
+			begin
+				yield
+			ensure
+				unlock
+			end
+ 		end
+
+		def synchronize_unless(cond)
+			unless cond
+				lock
+				begin
+					yield
+				ensure
+					unlock
+				end
+			else
+				yield
+			end
+		end
+
+	end
+end

data/src/iowa/Policy.rb

@@ -0,0 +1,70 @@
+require 'iowa/Constants'
+require 'digest/sha1'
+
+module Iowa
+
+  # An instance of Policy implements all of the functions
+  # surrounding session key creation and validation as well
+  # as the handling of getting/setting request and action
+  # ids in a URL or in a cookie.  This class implements the
+  # default IOWA policies in these areas and also serves
+  # as a template for the API that other policy classes
+  # must deliver.
+  
+  class Policy
+
+    RNDSesFormat = '%08x'.freeze
+
+    MatchURL = Regexp.new('(/*(?:[^/]*/*)*?)(\w+\-\w+\-\w+\.\w+\.[\w\.]+)*(-\w+)?$')
+
+    def initialize(args)
+      args = {:prng => Kernel} if args and args.empty?
+      args[:prng] ||= Kernel
+      @prng = args[:prng]
+    end
+
+    def rand(num)
+      @prng.rand(num)
+    end
+
+    def new_session_key
+      r1 = sprintf(RNDSesFormat,@prng.rand(2147483647))
+      r2 = sprintf(RNDSesFormat,@prng.rand(2147483647))
+      tn = Time.now
+      t = Digest::SHA1.hexdigest("#{tn.tv_sec}#{tn.tv_usec}")[C_0to7]
+      id = "#{r1}-#{r2}-#{t}"
+    end
+
+    def getIDs(url)
+      if (match = MatchURL.match url)
+        urlRoot = match[1]
+        remainder = match[2]? match[2] : C_empty
+        urlRoot.sub!(/\/$/,C_empty)
+        sessionID, requestID, actionID = remainder.split(C_dot,3)
+        [urlRoot, sessionID, requestID, actionID]
+      else
+        [nil,nil,nil,nil]
+      end
+    end
+
+    def baseURL(context)
+      context.urlRoot != '' ? "#{context.urlRoot}" : '/'
+    end
+
+    def sessionURL(context)
+        "#{context.urlRoot}/#{context.sessionID}"
+    end
+
+    def actionURL(context)
+      Iowa.app.location.to_s != C_empty ?
+        "#{context.urlRoot}/#{context.sessionID}.#{context.requestID}.#{context.elementID}-#{Iowa.app.location}" :
+        "#{context.urlRoot}/#{context.sessionID}.#{context.requestID}.#{context.elementID}"
+    end
+
+    def locationFlag(context)
+      Iowa.app.location.to_s != C_empty ?
+        "-#{Iowa.app.location}" : C_empty
+    end
+
+  end
+end

data/src/iowa/Pool.rb

@@ -0,0 +1,243 @@
+# Adapted from the Pool class in Facets, with additional smarts to enable it
+# to fullfill my needs as a dbpool that will monitor connections and recover
+# from failed connections (such as when the database is restarted) automatically,
+# so that the application using the pool never knows about it.
+
+require 'thread'
+require 'monitor'
+
+module Iowa
+	class Pool < Array
+
+		attr_accessor :start_size, :max_size, :min_size, :max_age, :monitor_interval, :logger, :in_use_count
+
+		include MonitorMixin
+
+		def self.StartSize(val = nil)
+			#@start_size ||= nil
+			(val or !@start_size) ? (@start_size = val || 1) : @start_size
+		end
+		def self.start_size(val = nil);StartSize(val);end
+
+		def self.MaxSize(val = nil)
+			#@max_size ||= nil
+			(val or !@max_size) ? (@max_size = val || 4) : @max_size
+		end
+		def self.max_size(val = nil);MaxSize(val);end
+
+		def self.MinSize(val = nil)
+			#@min_size ||= nil
+			(val or !@min_size) ? (@min_size = val || 1) : @min_size
+		end
+		def self.min_size(val = nil);MinSize(val);end
+
+		def self.MaxAge(val = nil)
+			#@max_age ||= nil
+			(val or !@max_age) ? (@max_age = val || nil) : @max_age
+		end
+		def self.max_age(val = nil);MaxAge(val);end
+
+		def self.MonitorInterval(val = nil)
+			#@monitor_interval ||= nil
+			(val or !@monitor_interval) ? (@monitor_interval = val || 300) : @monitor_interval
+		end
+		def self.monitor_interval(val = nil);MonitorInterval(val); end
+
+		def self.DoNotMonitor(val = nil)
+			#@do_not_monitor ||= nil
+			(val or @do_not_monitor.nil?) ? (@do_not_monitor = val || false) : @do_not_monitor
+		end
+		def self.do_not_monitor(val = nil);DoNotMonitor(val); end
+
+		def self.Logger(val = nil)
+			#@logger ||= nil
+			(val or @logger.nil?) ? (@logger = val || false) : @logger
+		end
+		def self.logger(val = nil);Logger(val); end
+
+		def set_monitor(l)
+			self.class.__send__(:define_method,:monitor,l)
+		end
+
+		def set_newobj(l)
+			self.class.__send__(:define_method,:newobj,l)
+		end
+
+		def set_valid(l)
+			self.class.__send__(:define_method,:valid?,l)
+		end
+
+		def initialize(params = {})
+			super()
+			@start_size = params[:start_size] || self.class.StartSize
+			@max_size = params[:max_size] || self.class.MaxSize
+			@min_size = params[:min_size] || self.class.MinSize
+			@max_size = 1 if @max_size < 1
+			@min_size = 0 if @min_size < 0
+			@start_size = 0 if @start_size < 0
+			@min_size = @max_size - 1 if @min_size > @max_size
+			@start_size = @min_size if @start_size > @max_size
+			@max_age = params[:max_age] || self.class.MaxAge
+			@monitor_interval = params[:monitor_interval] || self.class.MonitorInterval
+			@logger = params[:logger]
+			set_monitor(params[:monitor]) if params[:monitor]
+			set_newobj(params[:newobj]) if params[:newobj]
+			set_valid(params[:valid]) if params[:valid]
+			@params = params
+
+			@cv = new_cond()
+			@monitor_status = nil
+			@resource_age = {}
+			@in_use_count = 0
+			@start_size.times {no = newobj; push(no); @resource_age[no] = Time.now.to_i}
+			@in_use_count = 0
+			@monitor_thread = monitor_start unless params[:do_not_monitor] or self.class.DoNotMonitor
+		end
+
+		def log(msg)
+			if @logger
+				log_msg = "#{self.class.name} :: #{msg}"
+				if @logger.respond_to?(:info)
+					@logger.info(log_msg)
+				elsif @logger.respond_to?(:puts)
+					@logger.puts(log_msg)
+				elsif @logger.respond_to(:write)
+					@logger.write(log_msg)
+				end
+			end
+		end
+
+		def pool_size
+			length + @in_use_count
+		end
+
+		def monitor_start
+			if @monitor_status
+				@monitor_status = :running
+			else
+				@run_monitor = true
+				Thread.start {run_monitor}
+			end
+		end
+
+		def monitor_pause
+			log("Pausing monitoring.")
+			@monitor_status = :paused
+		end
+
+		def monitor_stop
+			@run_monitor = false
+		end
+
+		def run_monitor
+			log("Starting resource Pool monitor.  Interval is #{@monitor_interval} seconds.")
+			while @run_monitor
+				unless @monitor_status == :paused
+					do_monitor_age unless @monitor_status == :paused
+					do_monitor unless @monitor_status == :paused
+					do_monitor_minsize unless @monitor_status == :paused
+					#@monitor_status = :sleeping
+					sleep(@monitor_interval)
+				else
+					while @monitor_status == :paused
+						sleep 2
+					end
+				end
+				#@monitor_status = :running unless @monitor_status == :paused
+			end
+		end
+
+		def monitor_age(obj)
+			(Time.now.to_i - @resource_age[obj]) > @max_age if @max_age
+		end
+
+		def do_monitor_age
+			delete_list = []
+			each_index do |x|
+				delete_list.push(x) if monitor_age(self[x])
+			end
+			delete_list.each {|x| delete_at(x)}
+		end
+
+		def monitor(obj)
+			valid?(obj)
+		end
+
+		def do_monitor
+			each_index do |x|
+				self[x] = newobj unless monitor(self[x])
+			end
+		end
+
+		def do_monitor_minsize
+			while length < @min_size
+				push(newobj)
+			end
+		end
+
+		def newobj
+			true
+		end
+
+		def valid?(obj)
+			if obj.respond_to?(:ping)
+				obj.ping
+			elsif obj.respond_to?(:connected?)
+				obj.connected?
+			elsif obj.respond_to?(:alive?)
+				obj.alive?
+			else
+				obj
+			end
+		end
+
+		def push(obj)
+			synchronize do
+				if pool_size <= @max_size
+					super
+					@in_use_count -= 1
+					@resource_age[obj] = Time.now.to_i
+					@cv.signal()
+					true
+				else
+					false
+				end
+			end
+		end
+
+		def pop
+			synchronize do
+				obj = nil
+				if empty? and (pool_size < @max_size)
+					obj = newobj
+					@in_use_count += 1
+				else
+					@cv.wait_while {empty?} if empty?
+					obj = super
+					@resource_age.delete(obj)					
+					@in_use_count += 1
+				end
+				if !valid?(obj)
+					@in_use_count -= 1
+					sleep 1
+					redo
+				end
+				obj
+			end
+		end
+
+		def obtain
+			result = nil
+			begin
+				obj = pop()
+				result = yield(obj)
+			ensure
+				push(obj)
+			end
+			result
+		end
+
+	end
+
+end
+