IOWA 1.0.0

data/microprojects/DiskCache/external/test_support.rb

@@ -0,0 +1,8 @@
+module IWATestSupport
+
+	def self.cd_to_test_dir(dir)
+		Dir.chdir(File.dirname(File.expand_path(dir)))
+	end
+
+end
+

data/microprojects/DiskCache/setup.rb

@@ -0,0 +1,22 @@
+#!ruby
+
+basedir = File.dirname(__FILE__)
+$:.push(basedir)
+
+require 'external/package'
+require 'rbconfig'
+begin
+	require 'rubygems'
+rescue LoadError
+end
+
+Dir.chdir(basedir)
+Package.setup("1.0") {
+	name "Iowa::LinkedList"
+
+	translate(:lib, 'src/' => '')
+	lib *Dir["src/iowa/**/*.rb"]
+	ri *Dir["src/iowa/**/*.rb"]
+
+	unit_test ["test/TC_DiskCache.rb"]
+}

data/microprojects/DiskCache/src/iowa/Association.rb

@@ -0,0 +1,67 @@
+module Iowa
+	class Association
+	
+		def initialize(association)
+			@association = association
+		end
+
+		def association
+			@association
+		end
+
+		def test(object)
+			true
+		end
+	end
+
+	class PathAssociation < Association
+		def get(object,cache = false,stack_key = C_empty)
+			oca_key = "#{stack_key}/#{@association.hash}"
+			myval = object.cached_associations[oca_key]
+			if cache
+				usecache = myval ? true : false
+				usecache = false if myval.respond_to?(:empty?) and myval.empty? 
+			end
+			if cache and usecache
+				myval
+			else
+				object.cached_associations[oca_key] = object.valueForKeyPath(@association)
+			end
+		end
+	
+		def set(object, val)
+			object.takeValueForKeyPath(val, @association)
+		end
+
+		def test(object)
+			object.existsKeyPath?(@association)
+		end
+	end
+
+	class LiteralAssociation < Association
+
+		def get(object = nil, cache = false, stack_key = nil)
+			unless @association.is_a?(Proc)
+				@association
+			else
+				@association.call(object.send(:binding))
+			end
+		end
+	
+		def set(object, val)
+			@association = val
+		end
+	end
+
+	class FlexibleAssociation < Association
+		def FlexibleAssociation.new(association)
+			if association[0] == 123
+				association.sub!(/^\{/,C_empty)
+				association.sub!(/\}\s*$/,C_empty)
+				LiteralAssociation.new(Proc.new {|*ns| ns = ns[0] || binding ; eval(association,ns)})
+			else
+				PathAssociation.new(association)
+			end
+		end
+	end
+end

data/microprojects/DiskCache/src/iowa/Constants.rb

@@ -0,0 +1,159 @@
+require 'iowa/Association'
+require 'singleton'
+
+module Iowa
+
+	class UnknownValue
+		include Singleton
+		def to_s
+			'UNK'
+		end
+	end
+	alias :to_str :to_s
+
+	BindingKeywords = {'action' => [LiteralAssociation,true],
+		'id' => [LiteralAssociation, false],
+		'item' => [PathAssociation,true],
+		'list' => [PathAssociation,true],
+		'key' => [PathAssociation,true],
+		'klass' => [LiteralAssociation,true], # not 'class' because of HTML conflict
+		'tag' => [LiteralAssociation,true],
+		'condition' => [PathAssociation,true],
+		'value' => [PathAssociation,true]}
+
+	ClassSeparator = '::'.freeze
+	ContentClassesNamespace = 'Iowa::Application::ContentClasses'.freeze
+
+	C_empty = ''.freeze
+	C_ = ' '.freeze
+	C_anon_ = '_anon_'.freeze
+	C_at = '@'.freeze
+	C_atat = '@@'.freeze
+	C_bnd = '.bnd'.freeze
+	C_content = '_content'.freeze
+	C_default = '_default'.freeze
+	C_dot = '.'.freeze
+	C_dotdot = '..'.freeze
+	C_equal = '='.freeze
+	C_gt = '>'.freeze
+	C_item = '_item'.freeze
+	C_iwa = '.iwa'.freeze
+	C_list = '_list'.freeze
+	C_method = '_method'.freeze
+	C_semicolon = ';'.freeze
+	C_slash = '/'.freeze
+	C0 = '0'.freeze
+	C_0to7 = 0..7.freeze
+	C1 = '1'.freeze
+	Caction = 'action'.freeze
+	Caddresses = 'addresses'.freeze
+	Capplication = 'application'.freeze
+	Capplication_data = 'application/data'.freeze
+	Cbasedir = 'basedir'.freeze
+	Cbaselog = 'baselog'.freeze
+	Cbasename = 'basename'.freeze
+	Cbody = 'body'.freeze
+	CBodyContent = 'BodyContent'.freeze
+	Cbrowsers = 'browsers'.freeze
+	Cbutton = 'button'.freeze
+	Ccacheable = 'cacheable'.freeze
+	Ccheckbox = 'checkbox'.freeze
+	Cchecked = 'checked'.freeze
+	Cchecksum = 'checksum'.freeze
+	CClass = 'Class'.freeze
+	Cclass = 'class'.freeze
+	Ccondition = 'condition'.freeze
+	CContentClasses = 'ContentClasses'.freeze
+	CCookie = 'Cookie'.freeze
+	Ccookie = 'cookie'.freeze
+	Cdaemonize = 'daemonize'.freeze
+	Cdatabase = 'database'.freeze
+	Cdefault = 'default'.freeze
+	Cdepth = 'depth'.freeze
+	Cdirectory = 'directory'.freeze
+	Cdispatcher = 'dispatcher'.freeze
+	Cdoc_root = 'doc_root'.freeze
+	Cdocroot = 'docroot'.freeze
+	CdynamicString = 'dynamicString'.freeze
+	Celement = 'element'.freeze
+	Cexceptions = 'exceptions'.freeze
+	Cfalse = 'false'.freeze
+	CFALSE = 'false'.freeze
+	Cfilename = 'filename'.freeze
+	Cfiles = 'files'.freeze
+	Cforce = 'force'.freeze
+	CEIN = 'EIN'.freeze
+	CHash = 'Hash'.freeze
+	Cheight = 'height'.freeze
+	Chostname = 'hostname'.freeze
+	Chosts = 'hosts'.freeze
+	Chref = 'href'.freeze
+	Cid = 'id'.freeze
+	Cimage = 'image'.freeze
+	Cimage_path = 'image_path'.freeze
+	Cinterval = 'interval'.freeze
+	Ciowa_log = 'iowa_log'.freeze
+	Ciowa_root = 'iowa_root'.freeze
+	Cips = 'ips'.freeze
+	Citem = 'item'.freeze
+	Ckey = 'key'.freeze
+	Cklass = 'klass'.freeze
+	Clabel = 'label'.freeze
+	Clast_modification = 'last_modification'.freeze
+	Clibrary = 'library'.freeze
+	Clink = 'link'.freeze
+	Clist = 'list'.freeze
+	CLocation = 'Location'.freeze
+	Clog_root = 'log_root'.freeze
+	Clogging = 'logging'.freeze
+	Clonely_tag_terminator = ' />'.freeze
+	CMain = 'Main'.freeze
+	Cmapfile = 'mapfile'.freeze
+	Cmaxage = 'maxage'.freeze
+	Cmaxsize = 'maxsize'.freeze
+	Cmethod = 'method'.freeze
+	Cminlevel = 'minlevel'.freeze
+	Cmodel = 'model'.freeze
+	Cmultiple = 'multiple'.freeze
+	Cname = 'name'.freeze
+	COK = 'OK'.freeze
+	Cpage = 'page'.freeze
+	Cpagecache = 'pagecache'.freeze
+	Cparams = 'params'.freeze
+	Cpath = 'path'.freeze
+	Cpolicy = 'policy'.freeze
+	Cport = 'port'.freeze
+	Cplural = 'plural'.freeze
+	Cpost = 'post'.freeze
+	Cradio = 'radio'.freeze
+	Crefresh = 'refresh'.freeze
+	Crequest_cacheable = 'request_cacheable'.freeze
+	Croot_path = 'root_path'.freeze
+	Croot_url = 'root_url'.freeze
+	Cscreens = 'screens'.freeze
+	Cselected = 'selected'.freeze
+	Cserialize_templates = 'serialize_templates'.freeze
+	Csession = 'session'.freeze
+	Csessioncache = 'sessioncache'.freeze
+	Csingular = 'singular'.freeze
+	Csocket = 'socket'.freeze
+	Csrc = 'src'.freeze
+	Csubmit = 'submit'.freeze
+	Ctagclass = 'tagclass'.freeze
+	Ctag = 'tag'.freeze
+	CtemplateRoot = 'templateRoot'.freeze
+	Ctext_html = 'text/html'.freeze
+	Ctext_javascript = 'text/javascript'.freeze
+	Ctitle = 'title'.freeze
+	Ctrue = 'true'.freeze
+	CTRUE = 'TRUE'.freeze
+	Cttl = 'ttl'.freeze
+	Ctype = 'type'.freeze
+	Cuse_lockfile = 'use_lockfile'.freeze
+	CUserAgent = 'User-Agent'.freeze
+	Cvalue = 'value'.freeze
+	Cvariation = 'variation'.freeze
+	Cwebrick = 'webrick'.freeze
+	Cwidth = 'width'.freeze
+
+end

data/microprojects/DiskCache/src/iowa/DiskStore.rb

@@ -0,0 +1,377 @@
+require 'thread'
+require 'iowa/AbstractCache'
+require 'iowa/Lockfile'
+require 'digest/sha2'
+require 'fileutils'
+require 'find'
+require 'tmpdir'
+require 'iowa/LRUCache'
+
+class Mutex
+	def synchronize_unless(cnd)
+		unless cnd
+			synchronize {yield}
+		else
+			yield
+		end
+	end
+end
+
+module Iowa
+
+	# DiskStore is a stripped down version of Iowa::Caches::DiskCache.
+	# DiskStore removes all of the LRU cache trappings, leaving a simple
+	# persistence engine.
+
+	class DiskStore < Iowa::AbstractCache
+
+		DEFAULT_BUCKET_WIDTH = 2
+		DEFAULT_BUCKET_DEPTH = 2
+
+		class NoCacheDir < Exception
+			def initialize(*args)
+				@bad_dir = args[0]
+			end
+
+			def to_s
+				"The cache directory (#{@bad_dir}) does not exist."
+			end
+		end
+
+		class DirNotEmpty < Exception
+			def initialize(*args)
+				@bad_dir = args[0]
+			end
+
+			def to_s
+				"The cache directory (#{@bad_dir}) is not empty."
+			end
+		end
+
+		class DeletedValue
+			attr_accessor :val
+			def initialize(v)
+				@val = v
+			end
+		end
+
+		def initialize(arg1 = {}, force = nil, width = DEFAULT_BUCKET_WIDTH, depth = DEFAULT_BUCKET_DEPTH, use_lockfile = false)
+			@transaction_cache = []
+			@transaction_lock = [nil,Mutex.new]
+			@cache_dir = nil
+			if arg1.respond_to?(:keys)
+				oargs = arg1
+				arg1 = Iowa::Hash.new
+				arg1.step_merge!(oargs)
+				arg1.stringify_keys!
+				if arg1[Cdirectory]
+					@cache_dir = arg1[Cdirectory]
+				else
+					@cache_dir = File.join(Dir::tmpdir,"tmp#{Time.now.to_f}")
+					FileUtils.mkdir(@cache_dir)
+				end
+				set_cachefile_paths
+				force = arg1[Cforce] || force
+				@bucket_depth = arg1[Cdepth] || depth
+				@bucket_width = arg1[Cwidth] || width
+				@use_lockfile = arg1[Cuse_lockfile] || use_lockfile
+			else
+				@cache_dir = arg1
+				set_cachefile_paths
+				arg1 = {}
+				@bucket_depth = depth
+				@bucket_width = width
+				@use_lockfile = use_lockfile
+			end
+
+			super(arg1)
+		
+			@bucket_depth_array = (0..(@bucket_depth - 1)).to_a
+			@locked = false
+
+			unless @use_lockfile
+				@mutex = Mutex.new
+			else
+				@lockfile = Iowa::Lockfile.new(File::join(@cache_dir,'cachelock.lck'))
+			end
+		
+			if !FileTest.exist?(@cache_dir)
+				if force
+					FileUtils.mkdir_p(@cache_dir)
+				else
+					raise Iowa::Caches::DiskCache::NoCacheDir.new(@cache_dir)
+				end
+			end
+		end
+
+		# Check to see if the cache contains the given key.
+
+		def include?(key)
+			if !@bypass_transactions and transaction_cache_include?(key)
+				if transaction_cache_get(key).is_a?(DeletedValue)
+					false
+				else
+					true
+				end
+			else
+				FileTest.exist?(datafile_for_key(key))
+			end
+		end
+
+		# Remove a key/value pair from the cache, by key.
+	
+		def delete(key)
+			lock_cache do
+				if !@bypass_transactions and transaction_cache_include?(key)
+					tcg = transaction_cache_get(key)
+					unless tcg.is_a?(DeletedValue)
+						@transaction_cache.last[key] = DeletedValue.new(tcg)
+					end
+				elsif FileTest.exist?(datafile_for_key(key))
+					if @transaction_lock[0] and @transaction_cache.length > 0
+						@transaction_cache.last[key] = DeletedValue.new(self[key])
+					else
+						File::unlink(datafile_for_key(key))
+			
+						#new_count = getdata(@cache_count,false) - 1
+						#putdata(new_count,@cache_count)
+					end
+				end
+			end
+		end
+
+		# Return the element identified by the given key.
+
+		def [](key)
+			r = nil
+			lock_cache do
+				if !@bypass_transactions and transaction_cache_include?(key)
+					transaction_cache_get(key)
+				else
+					datafile = datafile_for_key(key)
+					if FileTest.exist?(datafile)
+						FileUtils::touch(datafile)
+						r = getdata(datafile,false)
+					end
+				end
+			end
+			r
+		end
+	
+		def prune
+			tail = getdata(@cache_tail)
+			delete(getdata(File.join(path_for_hash(tail),"#{tail}.key"))) if tail
+		end
+
+		def attach(key, val)
+			lock_cache do
+				already_in_cache = include?(key)
+
+				#putdata((getdata(@cache_count) + 1),@cache_count,false) unless already_in_cache
+				# Write the data file.
+				putdata(val,datafile_for_key(key))
+			end
+		end
+	
+		# Set the element of the cache identified by the given key.  
+
+		def []=(key, val)
+			lock_cache do
+				if !@bypass_transactions and @transaction_cache.length > 0
+					@transaction_cache.last[key] = val
+				else
+					attach(key, val)
+				end
+			end
+		end
+
+		# Allows one to set the maximum size of the cache queue.  If the queue
+		# is currently larger than the size that it is being set to, elements
+		# will be expired until the queue is at the maximum size.
+
+		def size=(max)
+		end
+		alias maxsize= size=
+
+		# Return the maximum size of the cache.
+		def maxsize
+		end
+
+		# Return the current size of the cache.
+		def size
+			#getdata(@cache_count)
+		end
+
+		def ttl=(newttl)
+		end
+		alias maxttl= ttl=
+
+		def ttl
+			getdata(@maxttl)
+		end
+	
+		# Return a copy of current set of keys to cache elements.
+		def queue
+			r = []
+			Find::find(@cache_dir) do |p|
+				if p =~ /#{File::SEPARATOR}[^#{File::SEPARATOR}]+.key$/
+					r.push getdata(p)
+				end
+			end
+			r
+		end
+	
+		def transaction(&b)
+			Thread.critical = true
+			if @transaction_lock[0] and @transaction_cache.length > 0
+				if Thread.current == @transaction_lock[0]
+					Thread.critical = false
+					inner_transaction(b)
+					return true
+				end
+			else
+				@transaction_lock[0] = Thread.current
+			end
+			Thread.critical = false
+			@transaction_lock[1].synchronize {inner_transaction(b)}
+			@transaction_lock[0] = nil
+		end
+
+		def commit(final = false)
+			Thread.critical = true
+			transactions = @transaction_cache.pop
+			q = transactions.queue
+			(q.length - 1).downto(0) do |x|
+				k = q[x]
+				v = transactions[k]
+				if v.is_a?(DeletedValue)
+					@bypass_transactions = true
+					self.delete(k)
+					@bypass_transactions = false
+				else
+					@bypass_transactions = true
+					self[k] = transactions[k]
+					@bypass_transactions = false
+				end
+			end
+			unless final
+				@transaction_cache.push Iowa::Caches::LRUCache.new({:maxsize => 4294967296})
+			end
+			Thread.critical = false
+		end
+
+		def rollback
+			Thread.critical = true
+			@transaction_cache.pop
+			@transaction_cache.push Iowa::Caches::LRUCache.new({:maxsize => 4294967296})
+			Thread.critical = true
+		end
+
+		private
+
+		def inner_transaction(blk)
+			@transaction_cache.push Iowa::Caches::LRUCache.new({:maxsize => 4294967296})
+			blk.call
+			Thread.critical = true
+			commit(true)
+			Thread.critical = false
+		end
+
+		def transaction_cache_include?(key)
+			@transaction_cache.each do |tc|
+				return true if tc.include? key
+			end
+			false
+		end
+
+		def transaction_cache_get(key)
+			(@transaction_cache.length - 1).downto(0) do |x|
+				return @transaction_cache[x][key] if @transaction_cache[x].include?(key)
+			end
+			nil
+		end
+
+		def lock_cache
+			Thread.critical = true
+			transaction_in_progress = (@transaction_lock[0] and @transaction_cache.length > 0) ? true : false
+			@transaction_lock[0] = Thread.current unless transaction_in_progress
+			Thread.critical = false if transaction_in_progress
+			@transaction_lock[1].synchronize_unless(@transaction_lock[0] == Thread.current) do
+				Thread.critical = false unless transaction_in_progress
+				unless @locked
+					begin
+						if @use_lockfile
+							@lockfile.lock {@locked = true; yield}
+						else
+							@mutex.synchronize {@locked = true; yield}
+						end
+					ensure
+						@locked = false
+					end
+				else
+					yield
+				end
+			end
+			@transaction_lock[0] = nil unless transaction_in_progress
+		end
+
+		def hash_for_key(key)
+			Digest::SHA512.hexdigest(Marshal.dump(key))
+		end
+
+		def path_for_hash(hash)
+			# Take the hash key and break it apart by bucket_depth and bucket_width
+			# to return the path to the directory that should contain the
+			# cache element.
+			File.join(@cache_dir,@bucket_depth_array.collect {|d| hash[(d * @bucket_width),@bucket_width]})
+		end
+
+		def datafile_for_key(key)
+			h = hash_for_key(key)
+			File.join(path_for_hash(h),"#{h}.dat")
+		end
+
+		def getdata(filename,do_lock = true)
+			r = nil
+			if do_lock
+				lock_cache do
+					if FileTest::exist?(filename)
+						File.open(filename) {|fh| r = Marshal.load(fh)}
+					end
+				end
+			else
+				if FileTest::exist?(filename)
+					File.open(filename) {|fh| r = Marshal.load(fh)}
+				end
+			end
+			r
+		end
+
+		def getdata_worker(filename)
+			if FileTest::exist?(filename)
+				File.open(filename) {|fh| Marshal.load(fh)}
+			else
+				nil
+			end
+		end
+
+		def putdata(value,filename,do_lock = true)
+			if do_lock
+				lock_cache do
+					putdata_worker(value,filename)
+				end
+			else
+				putdata_worker(value,filename)
+			end
+		end
+
+		def putdata_worker(value,filename)
+			FileUtils.mkdir_p(File::dirname(filename)) unless FileTest.exist?(File::dirname(filename))
+			File.open(filename,'w') {|fh| Marshal.dump(value,fh)}
+		end
+
+		def set_cachefile_paths
+			#@cache_count = File.join(@cache_dir,'cache_count.inf')
+		end
+	end
+end