IOWA 1.0.0

data/src/iowa/loggers/Analogger.rb

@@ -0,0 +1,54 @@
+begin
+  load_attempted ||= false
+  require 'iowa/Logger'
+  require 'swiftcore/Analogger/Client'
+rescue LoadError => e
+  unless load_attempted
+    load_attempted = true
+    require 'rubygems'
+    retry
+  else
+    raise e
+  end
+end
+
+module Iowa
+  module Loggers
+    class Analogger < Iowa::Logger
+
+      def configure
+        conf = Iowa.config[Clogger]
+        conf[Cservice] ||= 'default'
+        conf[Chost] ||= '127.0.0.1'
+        conf[Cport] ||= 6766
+        conf[Ckey] = nil unless conf.has_key?(Ckey)
+      end
+
+      def open
+        conf = Iowa.config[Clogger]
+        @logger = ::Swiftcore::Analogger::Client.new(conf[Cservice],conf[Chost],conf[Cport],conf[Ckey])
+      end
+
+      def debug(msg)
+        @logger.log(Cdebug,msg)
+      end
+
+      def info(msg)
+        @logger.log(Cinfo,msg)
+      end
+
+      def warn(msg)
+        @logger.log(Cwarn,msg)
+      end
+
+      def error(msg)
+        @logger.log(Cerror,msg)
+      end
+
+      def fatal(msg)
+        @logger.log(Cfatal,msg)
+      end
+
+    end
+  end
+end

data/src/iowa/loggers/AsyncLogger.rb

@@ -0,0 +1,54 @@
+require 'iowa/Logger'
+
+module Iowa
+  module Loggers
+    class AsyncLogger < Iowa::Logger
+      def initialize
+        @queue = []
+        @periodic_flush = Thread.start { flush_periodically }
+        super
+      end
+
+      def debug(msg)
+        @queue << [:debug,msg]
+      end
+
+      def info(msg)
+        @queue << [:info,msg]
+      end
+
+      def warn(msg)
+        @queue << [:warn,msg]
+      end
+
+      def error(msg)
+        @queue << [:error,msg]
+      end
+
+      def fatal(msg)
+        @queue << [:fatal,msg]
+      end
+
+      def close
+        @periodic_flush.stop
+        flush
+        super
+      end
+
+      def flush_periodically
+        loop do
+          sleep 1
+          flush
+        end
+      end
+
+      def flush
+        while msg = @queue.shift
+          @logger.__send__(msg.first,msg.last)
+          msg = nil
+        end
+      end
+
+    end
+  end
+end

data/src/iowa/loggers/BitBucket.rb

@@ -0,0 +1,38 @@
+begin
+  load_attempted ||= false
+  require 'iowa/Logger'
+rescue LoadError => e
+  unless load_attempted
+    load_attempted = true
+    require 'rubygems'
+    retry
+  else
+    raise e
+  end
+end
+
+module Iowa
+  module Loggers
+    class BitBucket < Iowa::Logger
+
+      def open
+      end
+
+      def debug(msg)
+      end
+
+      def info(msg)
+      end
+
+      def warn(msg)
+      end
+
+      def error(msg)
+      end
+
+      def fatal(msg)
+      end
+
+    end
+  end
+end

data/src/iowa/loggers/Log4R.rb

@@ -0,0 +1,13 @@
+require 'iowa/Logger'
+require 'log4r'
+
+module Iowa
+  module Loggers
+    class Log4R < Iowa::Logger
+
+      def open
+      end
+
+    end
+  end
+end

data/src/iowa/loggers/Log4rLogger.rb

@@ -0,0 +1,48 @@
+require 'iowa/Logger'
+require 'log4r'
+
+module Iowa
+  module Loggers
+    class Log4rLogger < Iowa::Logger
+
+      def check_errors
+        if Iowa.config.has_key? Clogging
+          if Iowa.config[Clogging].has_key? Cbasedir
+            raise "The logging basedir (#{File.join(Iowa::Application.root_directory, Iowa.config[Clogging][Cbasedir])}) must be a directory." unless FileTest.directory? File.join(Iowa::Application.root_directory, Iowa.config[Clogging][Cbasedir])
+            raise "The logging basedir (#{File.join(Iowa::Application.root_directory, Iowa.config[Clogging][Cbasedir])}) must be writeable." unless FileTest.writable? File.join(Iowa::Application.root_directory,Iowa.config[Clogging][Cbasedir])
+          end
+    
+          raise "The minimum logging level (minlevel) must be an integer between 0 to 7, inclusively." if Iowa.config[Clogging].has_key? Cminlevel and (Iowa.config[Clogging][Cminlevel] < 0 or Iowa.config[Clogging][Cminlevel] > 7)
+    
+          raise "The maximum log file size (maxsize) must be greater than zero." if Iowa.config.has_key? Cmaxsize and Iowa.config[Cmaxsize] <= 0
+
+          raise "The maximum log file age (maxage) must be greater than zero." if Iowa.config.has_key? Cmaxage and Iowa.config[Cmaxage] <= 0
+        end
+      end
+
+      def configure
+        check_errors
+
+        Iowa.config[Clogging][Cbasedir] = '/tmp' unless Iowa.config[Clogging].has_key? Cbasedir
+        Iowa.config[Clogging][Cminlevel] = 0 unless Iowa.config[Clogging].has_key? Cminlevel
+        Iowa.config[Clogging][Cmaxsize] = 1024 * 1024 unless Iowa.config[Clogging].has_key? Cmaxsize
+        Iowa.config[Clogging][Cmaxage] = 86400 unless Iowa.config[Clogging].has_key? Cmaxage
+        if Iowa.config[Csocket].has_key? Cpath
+          Iowa.config[Clogging][Cfilename] = "#{Iowa.config[Clogging][Cbasedir]}/#{Iowa.config[Csocket][Cbasename]}.log" if Iowa.config[Clogging][Cfilename].nil? or Iowa.config[Clogging][Cfilename] == {}
+        else
+          Iowa.config[Clogging][Cfilename] = "#{Iowa.config[Clogging][Cbasedir]}/#{Iowa.config[Csocket][Chostname]}_#{Iowa.config[Csocket][Cport]}.log" if Iowa.config[Clogging][Cfilename].nil? or Iowa.config[Clogging][Cfilename] == {}
+        end
+      end
+
+      def open
+        lcfg = Iowa.config[Clogging]
+        @logger = ::Log4r::Logger.new ::Iowa::Ciowa_log
+        myformat = ::Log4r::PatternFormatter.new :pattern => '[%l] %C @ %d :: %M'
+        mybaselog = ::Log4r::RollingFileOutputter.new Cbaselog, :maxsize => lcfg[Cmaxsize], :maxtime => lcfg[Cmaxage], :level => lcfg[Cminlevel], :filename => lcfg[Cfilename], :trunc => false, :formatter => myformat
+        @logger.outputters = mybaselog
+
+        @logger.info 'Log4R Logging subsystem initialized.'
+      end
+    end
+  end
+end

data/src/iowa/loggers/Logger.rb

@@ -0,0 +1,29 @@
+require 'iowa/Logger'
+require 'logger'
+
+module Iowa
+  module Loggers
+    class Logger < Iowa::Logger
+      Intervals = {:daily => true, :weekly => true, :monthly => true}
+
+      def open
+        log_root = Iowa.config[Clogger].has_key?(Cbasedir) ?
+          ( Iowa.config[Clogger][Cbasedir].index('/') == 0 ?
+            File.expand_path( Iowa.config[Clogger][Cbasedir] ) :
+            File.expand_path( File.join( Iowa::Application.iowa_root, Iowa.config[Clogger][Cbasedir] ) ) ) :
+          Iowa::Application.log_root 
+        logfile = File.join(log_root, (Iowa.config[Clogger][Cfilename] || 'iowa.log'))
+        logargs = []
+        if Intervals.has_key?(Iowa.config[Clogger][Cmaxage].to_s.downcase.intern)
+          logargs << Iowa.config[Clogger][Cmaxage].to_s.downcase
+        else
+          maxfiles = Iowa.config[Clogger].has_key?(Cmaxfiles) ? Iowa.config[Clogger][Cmaxfiles] : 10
+          logargs << maxfiles
+          logargs << Iowa.config[Clogger][Cmaxsize] || 1024 * 1024
+        end
+        @logger = ::Logger.new(logfile,*logargs)
+      end
+
+    end
+  end
+end

data/src/iowa/loggers/RubyLogger.rb

@@ -0,0 +1,9 @@
+require 'iowa/loggers/Logger'
+require 'logger'
+
+module Iowa
+  module Loggers
+    class RubyLogger < Iowa::Loggers::Logger
+    end
+  end
+end

data/src/iowa/pools/DBConnectionPool.rb

@@ -0,0 +1,53 @@
+require 'iowa/Pool'
+
+module Iowa
+	class Pool
+		class DBConnectionPool < Iowa::Pool
+
+			def self.DBClass(val = nil)
+				if (val or !@dbclass)
+					if val
+						@dbclass = val
+					else
+						require 'dbi'
+						@dbclass = DBI
+					end
+					DBNewMethodName()
+				end
+				@dbclass
+			end
+			def self.db_class(val = nil); DBClass(val); end
+
+			def self.DBNewMethodName(val = nil)
+				@db_new_method_name ||= nil
+				if (val or !@db_new_method_name)
+					if val
+						@db_new_method_name = val
+					else
+						@db_new_method_name = @dbclass == DBI ? :connect : :new
+					end
+				else
+					@db_new_method_name
+				end
+			end
+			def self.db_new_method_name(val = nil); DBNewMethodName(val = nil); end
+
+			def self.ConnectArgs(val = nil)
+				(val or !@connect_args) ? (@connect_args = val) : @connect_args
+			end
+			def self.connect_args(val = nil); ConnectArgs(val); end
+
+			def initialize(params = {})
+				@connect_args = params[:connect_args] || self.class.ConnectArgs
+				@dbclass = params[:dbclass] || self.class.DBClass
+				@db_new_method_name = params[:db_new_method_name] || self.class.DBNewMethodName
+				super
+			end
+
+			def newobj
+				@dbclass.__send__(@db_new_method_name,*@connect_args)
+			end
+		end
+	end
+end
+

data/src/iowa/request/Apache.rb

@@ -0,0 +1,90 @@
+require 'iowa/Request'
+
+module Iowa
+
+	class Request
+
+		class Apache < Iowa::Request
+
+			def aah_to_a(val)
+				return val unless val.is_a?(::Apache::ArrayHeader)
+				r = []
+				val.each {|v| r << v}
+				r
+			end
+
+			def setup(request)
+				@hostname = request.hostname
+				@unparsed_uri = request.unparsed_uri
+				@uri = request.uri
+				@filename = request.filename
+				@request_time = request.request_time
+				@request_method = request.request_method
+				@header_only = request.header_only?
+				# In an Apache::Request object, request.args is a string.  We want
+				# to make a hash of these contents available for use, too.
+				@args = request.args
+				@args = '' if args.nil?
+				@content_type = request.content_type
+				@content_encoding = request.content_encoding
+				@content_languages = aah_to_a(request.content_languages)
+				@remote_host = request.remote_host(::Apache::REMOTE_HOST)
+				@remote_addr = request.remote_host(::Apache::REMOTE_NOLOOKUP)
+				@auth_type = request.auth_type
+				@auth_name = request.auth_name
+				@cache_resp = request.cache_resp
+				@params = Hash.new
+				if @args.to_s != C_empty
+					@args.split(/&/).each do |a|
+						k,v = a.split(/=/,2).collect{|x| Iowa::Util.unescape(x)}
+						if @params.has_key? k
+							if @params[k].respond_to?(:push)
+								@params[k] << (v or C_empty)
+							else						    
+								@params[k] = [(v or C_empty)]
+							end
+						else
+							@params[k] = (v or C_empty)
+						end
+					end
+				else
+					if m = MIMERegexp.match(request.headers_in['Content-Type'])
+						boundary = m[1]
+						@params = read_multipart(boundary,request.headers_in['Content-Length'],$stdin,request.headers_in['HTTP_USER_AGENT'])
+					else
+						@content = $stdin.read
+						@content = '' if @content.nil?
+						@content.split(/[&;]/).each do |x|
+							key, val = x.split(/=/,2).collect{|x| Iowa::Util.unescape(x)}
+							if @params.include?(key)
+								@params[key] += "\0" + (val or "")
+							else
+								@params[key] = (val or "")
+							end
+						end
+					end
+				end
+				@headers = Iowa::DataTable.new
+				request.headers_in.each do |key,value|
+					@headers[key] = value
+				end
+				#@status_line = request.status_line
+				#@headers_out = Iowa::DataTable.new
+				#request.headers_out.each do |key,value|
+				#	@headers_out[key] = value
+				#end
+			end
+
+			def initialize(request=nil)
+				unless request
+					request = Apache.request if ENV['MOD_RUBY']
+				end
+
+				setup(request)
+			end
+
+		end
+	end
+end
+
+Iowa::Request.Type = Iowa::Request::Apache

data/src/iowa/request/EMHybrid.rb

@@ -0,0 +1,59 @@
+require 'iowa/Request'
+require 'time'
+
+module Iowa
+
+	class Request
+
+		# This class encapsulates an EM Hybrid request.  This is a request that
+		# was received by EventMachine but was parsed by the Mongrel HTTP
+		# parser.
+		
+		class EMHybrid < Iowa::Request
+
+			def setup(headers,params,body)
+				hn = headers[CX_FORWARDED_HOST] || headers[CHTTP_HOST] || headers[CHOST]
+				@hostname,@port = hn.split(/:/)
+				@unparsed_uri = params[CREQUEST_URI]
+				@uri = params[CREQUEST_URI].gsub(/\?.*$/,'')
+				#@uri = params[CPATH_INFO]
+				@request_time = Time.now.httpdate
+				@request_method = params[CREQUEST_METHOD]
+				#@remote_host = request.params[::Mongrel::Const::REMOTE_HOST]
+				#@remote_addr = request.params[::Mongrel::Const::REMOTE_ADDR]
+				@header_only =  (@request_method == CHEAD) ? true : false
+				@args = params[CQUERY_STRING]
+
+				@headers_in = @headers = headers
+				
+				@params = {}
+				if m = MIMERegexp.match(@headers[CContent_type])
+					boundary = m[1]
+					@params = read_multipart(boundary,@headers[CContent_length],body,@headers[CUser_agent])
+				else
+					body.each_line {|line| parse_params(line)}
+				end
+
+				parse_params(@args) if @args
+				
+				@status_line = nil
+				@headers_out = Iowa::DataTable.new
+				@content_type = nil
+				@content_encoding = nil
+				@content_languages = nil
+				@content = ''
+			end
+
+			def initialize(headers,params,body)
+
+				@calculate_runtime = false
+
+				setup(headers,params,body)
+			end
+
+		end
+	end
+end
+
+Iowa::Request.Type = Iowa::Request::EMHybrid
+