sdb_dal 0.0.5 → 0.0.6

data/lib/sdb_dal/crypto.rb

@@ -0,0 +1,51 @@
+require "openssl"
+include OpenSSL
+ 
+module SdbDal
+  class Crypto
+    include OpenSSL::Cipher
+    def initialize(options={})
+      key_dir=options[:key_dir] if options.has_key?(:key_dir)
+      key_dir ||="/tmp"
+      @cipher = Cipher.new("AES-256-CBC")
+
+      if File.exists?(key_dir+'/.cipher_key')
+        @key=File.open(key_dir+'/.cipher_key').read
+      else
+        @key =  @cipher.random_key()
+        File.open(key_dir+"/.cipher_key",'w').write(@key)
+      end
+
+
+
+
+      if File.exists?(key_dir+'/.cipher_iv')
+        @iv=File.open(key_dir+'/.cipher_iv').read
+      else
+        @iv =  @cipher.random_iv()
+        File.open(key_dir+"/.cipher_iv",'w').write(@iv)
+      end
+    end
+
+    def encrypt(text)
+
+      @cipher.encrypt(@key,@iv)
+      @cipher.key=@key
+      @cipher.iv = @iv
+      e = @cipher.update(text)
+      e << @cipher.final()
+      Base64.encode64(e)#.chomp
+
+    end
+
+    def decrypt(text)
+      x=Base64.decode64(text)
+      @cipher.decrypt(@key,@iv)
+      @cipher.key = @key
+      @cipher.iv = @iv
+      d = @cipher.update(x)
+      d << @cipher.final()
+      return  d
+    end
+  end
+end

data/lib/sdb_dal/domain_attribute_description.rb

@@ -6,15 +6,21 @@ class DomainAttributeDescription
   attr_accessor :value_type 
   attr_accessor :is_primary_key
   attr_accessor :is_collection
-  
+  attr_accessor :is_encrypted
+
+  def self.crypto
+    @@crypto||=Crypto.new
+    @@crypto
+  end
     
-  def initialize(name,type,options)
+  def initialize(name,type,is_encrypted=false,options={})
     self.name=name
     self.value_type=type
     self.is_collection=(type==:reference_set)
-    self.is_collection ||= ( options.has_key?(:is_collection) and options[:is_collection])
-    
+    self.is_collection ||= ( options.has_key?(:is_collection) and options[:is_collection])  
     self.is_primary_key=options.has_key?(:is_primary_key)  && options[:is_primary_key]==true
+    self.is_encrypted=is_encrypted 
+    self.is_encrypted=options[:is_encrypted] if options.has_key?(:is_encrypted)  
   end
   def is_clob
     return self.value_type==:clob
@@ -23,29 +29,33 @@ class DomainAttributeDescription
       return format_for_sdb_single( value) unless self.is_collection==true
        result=[]
        value.each do |single_value|
-           result<<format_for_sdb_single( single_value)
+           result << format_for_sdb_single( single_value)
        end
        result
   end
   def format_for_sdb_single(value)
     return nil if value == nil && self.value_type!=:boolean
       if self.value_type==:integer
-        return format_integer(value)
+        result= format_integer(value)
       elsif self.value_type==:reference_set
-          return format_reference_set(value)     
+        result= format_reference_set(value)     
       elsif self.value_type==:date
-          return format_date(value)     
+        result= format_date(value)     
       elsif self.value_type==:boolean
-          return format_boolean(value)     
+        result= format_boolean(value)     
       elsif self.value_type==:unsigned_integer
-             return format_unsigned_integer(value)    
+        result= format_unsigned_integer(value)    
       elsif self.value_type==:float
-            return format_float(value)
+        result= format_float(value)
       
       else
-            return format_string(value.to_s)
+        result= format_string(value.to_s)
       end
-      
+    if is_encrypted
+          result=DomainAttributeDescription.crypto.encrypt(result)
+        end
+
+    result      
   end
    def parse_from_sdb( value)
        return parse_from_sdb_single( value) unless self.is_collection==true
@@ -53,7 +63,7 @@ class DomainAttributeDescription
      
        result=[]
        value.each do |single_value|
-           result<<parse_from_sdb_single( single_value)
+           result << parse_from_sdb_single( single_value)
        end
        result
    end
@@ -61,7 +71,14 @@ class DomainAttributeDescription
         
        return nil if value==nil 
      
-       
+        if is_encrypted
+          begin
+          value=DomainAttributeDescription.crypto.decrypt(value)
+          rescue
+            #assume wasn't encrypted originally
+          end
+        end
+
        if self.value_type==:integer
         return parse_integer(value)
       elsif self.value_type==:date
@@ -80,4 +97,4 @@ class DomainAttributeDescription
       return value
     end
 end
-end
+end

data/lib/sdb_dal/domain_object.rb

@@ -1,13 +1,14 @@
 require "active_support"
-require 'uuid'
+require File.dirname(__FILE__) +'/uuid.rb'
 require File.dirname(__FILE__) +'/domain_attribute_description.rb'
 require File.dirname(__FILE__) +"/reference.rb"
 require File.dirname(__FILE__) +"/index_description.rb"
 require File.dirname(__FILE__) +"/lazy_loading_text.rb"
 require File.dirname(__FILE__) +"/repository_factory.rb"
+require File.dirname(__FILE__) +"/crypto.rb"
 module SdbDal
   class DomainObject
-  
+    @@is_encrypted=false
     @@items_to_commit=nil
     @@transaction_depth=0
     attr_accessor :sdb_key
@@ -52,22 +53,22 @@ module SdbDal
       []
     end
 
-    def self.index(name,columns,options={})
-       return if self.index_descriptions[name]
+    def self.index(index_name,columns,options={})
+      @index_descriptions||={}
+       return if self.index_descriptions[index_name]
       $columns_xxx=columns
       class_eval <<-GETTERDONE
 
-      @@index_descriptions||={}
-      unless @@index_descriptions.has_key?(:#{name})
-      @@index_names||=[]
-      @@index_names<<:#{name}
+      unless @index_descriptions.has_key?(:#{index_name})
+      @index_names||=[]
+      @index_names<<:#{index_name}
 
     def self.index_names
-        @@index_names
+        @index_names
     end
 
-    attribute_description=SdbDal::DomainAttributeDescription.new(:#{name},:string,{})
-    @@index_descriptions[:#{name}]=SdbDal::IndexDescription.new(:#{name},$columns_xxx)
+    attribute_description=SdbDal::DomainAttributeDescription.new(:#{index_name},:string,{})
+    @index_descriptions[:#{index_name}]=SdbDal::IndexDescription.new(:#{index_name},$columns_xxx,self.is_encrypted?)
    end
       GETTERDONE
      
@@ -94,33 +95,40 @@ module SdbDal
         find_scope=":first"
       end
       class_eval <<-GETTERDONE
-        def #{name}              
-            return	self.class.calculate_#{name}(#{getter_params.join(",")})
+        def #{index_name}              
+            return	self.class.calculate_#{index_name}(#{getter_params.join(",")})
         end
 
-       def self.calculate_#{name}(#{params.join(",")})
-            index_description=index_descriptions[:#{name}]
+       def self.calculate_#{index_name}(#{params.join(",")})
+            index_description=index_descriptions[:#{index_name}]
             h={}
             #{finder_code}
             index_description.format_index_entry(@@attribute_descriptions,h)
       end
-
-      def self.find_by_#{name}(#{params.join(",")},options={})
-          options[:params]={:#{name}=>self.calculate_#{name}(#{params.join(",")})}
-          options[:index]=:#{name}
-          options[:index_value]=self.calculate_#{name}(#{params.join(",")})
+      def self.find_by_#{index_name}(#{params.join(",")},options={})
+          options[:params]={:#{index_name}=>self.calculate_#{index_name}(#{params.join(",")})}
+          options[:index]=:#{index_name}
+          options[:index_value]=self.calculate_#{index_name}(#{params.join(",")})
            find(#{find_scope},options)
       end
       GETTERDONE
     end
 
 
-    @@index_descriptions ||={}
+    @index_descriptions ||={}
 
     def self.index_descriptions
-      @@index_descriptions || {}
+      @index_descriptions || {}
     end
 
+    def self.is_encrypted?
+      return @@is_encrypted || false
+    end
+    def self.encrypt_me
+      class_eval <<-GETTERDONE
+         @@is_encrypted=true
+      GETTERDONE
+    end
     def self.data_attribute(name,type,options={})
       class_eval <<-GETTERDONE
     @@attribute_descriptions||=HashWithIndifferentAccess.new 
@@ -152,7 +160,7 @@ module SdbDal
       GETTERDONE
     return if self.attribute_descriptions.has_key?(name)
   
-      attribute_description=DomainAttributeDescription.new(name,type,options)
+      attribute_description=DomainAttributeDescription.new(name,type,self.is_encrypted?,options)
       self.attribute_descriptions[name] = attribute_description
       @primary_key_attribute_names||=[]
       if attribute_description.is_primary_key 
@@ -248,7 +256,7 @@ module SdbDal
   
       class_eval <<-GETTERDONE
 	def #{accesser_attribute_name}
-		#{domain_class}.find(self.#{foreign_key_attribute})
+		#{module_name+domain_class.to_s}.find(self.#{foreign_key_attribute})
 	end
         
       GETTERDONE
@@ -281,10 +289,10 @@ module SdbDal
 
 	def #{accesser_attribute_name}
             #unless @accessor_cache.has_key? :#{accesser_attribute_name}
-      		through_results= #{through_class}.find(:all,:map=>{:keys=>#{reflecting_array_code},:values=>DomainObject.arrayify(self.primary_key)})
+      		through_results= #{module_name+through_class.to_s}.find(:all,:map=>{:keys=>#{reflecting_array_code},:values=>DomainObject.arrayify(self.primary_key)})
                 result=[]
                 through_results.each do |through_result|
-                  item= #{domain_class}.find(through_result.#{foriegn_key_attribute}) 
+                  item= #{module_name+domain_class.to_s}.find(through_result.#{foriegn_key_attribute}) 
                   result<< item if item
                 end
                 #{order}
@@ -296,7 +304,7 @@ module SdbDal
             
 	end
         def connect_#{domain_class.to_s.downcase}(#{domain_class.to_s.downcase})
-            connector=#{through_class}.new
+            connector=#{module_name+through_class.to_s}.new
             connector.set_map(#{fkey_array_code},DomainObject.arrayify(#{domain_class.to_s.downcase}.primary_key))
             connector.set_map(#{reflecting_array_code},DomainObject.arrayify(self.primary_key))
             connector.save
@@ -406,8 +414,9 @@ module SdbDal
       #  else
       class_eval <<-XXDONE
 	def #{accesser_attribute_name}
+
             if !@accessor_cache.has_key? :#{accesser_attribute_name}
-               result= #{domain_class}.find(:all,:map=>{:keys=>#{reflecting_array_code},:values=>DomainObject::arrayify(self.primary_key)}#{order})
+               result= #{module_name+domain_class.to_s}.find(:all,:map=>{:keys=>#{reflecting_array_code},:values=>DomainObject::arrayify(self.primary_key)}#{order})
                 @accessor_cache[:#{accesser_attribute_name}]=result || []
             end
             return @accessor_cache[:#{accesser_attribute_name}] 
@@ -537,7 +546,7 @@ module SdbDal
     end
     def save(options={})
       if !self.primary_key
-        self.primary_key= UUID.generate.to_s
+        self.primary_key= SdbDal::UUID.generate
       end
         
       if @@transaction_depth>0
@@ -594,6 +603,7 @@ module SdbDal
 
       return self.class.repository
     end
+
     class << self
       def repository(options={})
     
@@ -694,5 +704,10 @@ module SdbDal
       end
     
     end
+    def self.module_name
+       result=""
+      result=self.name.slice(0, self.name.rindex(":")+1) if self.name.rindex(":")
+      result
+    end
   end
 end

data/lib/sdb_dal/index_description.rb

@@ -4,12 +4,18 @@ class IndexDescription < DomainAttributeDescription
     include SdbFormatter
  attr_accessor :columns
   
+
+  def self.crypto
+    @@crypto||=Crypto.new
+    @@crypto
+  end
     
-  def initialize(name,columns)
+  def initialize(name,columns,is_encrypted=false)
     self.name=name
     self.columns=columns
     self.value_type =:string
     self.is_primary_key=false
+    self.is_encrypted=is_encrypted
   end
   
   def format_index_entry(attribute_descriptions,attribute_values)
@@ -18,12 +24,17 @@ class IndexDescription < DomainAttributeDescription
         if column.respond_to?(:transform)
           result << column.transform(attribute_values[column.source_column] )
         else
-          result<<attribute_descriptions[column].format_for_sdb(attribute_values[column]).to_s
+          result << attribute_descriptions[column].format_for_sdb(attribute_values[column]).to_s
         end
-        result<<"&"
+        result << "&"
       end
+      
       result
   end
+  def format_for_sdb(value)
+    #don't encrypt because the individual elements are encrypted
+    return value
+  end
   
 end
-end
+end

data/lib/sdb_dal/memcache_repository.rb

@@ -0,0 +1,89 @@
+module SdbDal
+
+  require File.dirname(__FILE__) +"/memory_storage.rb"
+
+  class MemcacheRepository
+    attr_accessor :use_cache #this here just so interface matches sdb repo
+    attr_accessor :storage
+
+    def initialize(
+        sdb_domain= nil,
+        clob_bucket= nil,
+        aws_key_id= nil,
+        aws_secret_key= nil,
+        memcache_servers = nil ,
+        a_storage=nil,
+        append_table_to_domain=nil
+      )
+      @storage||=Storage.new(aws_key_id,aws_secret_key,memcache_servers,[],{:memory_only=>(aws_key_id==nil) }  )
+      @sdb_domain=sdb_domain
+      @clob_bucket=clob_bucket
+    end
+    def pause
+    end
+
+    def clear_session_cache
+
+    end
+
+    def clear
+      
+    end
+
+    def save(table_name, primary_key, attributes,index_descriptions)
+      key=make_cache_key(table_name,primary_key);
+      record={}
+
+      attributes.each do |description,value|
+        
+          record[description.name]=value
+      end
+      record["metadata%table_name"]=table_name
+      record["metadata%primary_key"]=key
+      @storage.put(@clob_bucket,key,record)
+    end
+    def query_ids(table_name,attribute_descriptions,options)
+      raise " not supported for memcache repo"
+
+    end
+
+    def query(table_name,attribute_descriptions,options)
+      raise " not supported for memcache repo"
+    end
+    def find_one(table_name, primary_key,attribute_descriptions)#, non_clob_attribute_names, clob_attribute_names)
+
+      key=make_cache_key(table_name,primary_key)
+      @storage.get(@clob_bucket,key)
+
+
+    end
+    def get_clob(table_name,primary_key,clob_name)
+      raise " not supported for memcache repo"
+
+    end
+    def destroy(table_name, primary_key)
+      key=make_cache_key(table_name,primary_key);
+      @storage.put(@clob_bucket,key,nil)
+
+    end
+    private
+    def flatten_key(key)
+      if key.is_a?( Array)
+        flattened_key=""
+        key.each do |key_part|
+          flattened_key << CGI.escape(key_part.to_s)+"/"
+        end
+        return flattened_key[0..-2]
+      else
+        return CGI.escape(key.to_s)
+      end
+    end
+    def make_cache_key(table_name,primary_key)
+
+      primary_key=flatten_key(primary_key)
+      return "#{@sdb_domain}/#{table_name}/#{primary_key}"
+    end
+
+  end
+
+end

data/lib/sdb_dal/memory_repository.rb

@@ -55,7 +55,9 @@ module SdbDal
           index_value=record[index_name.to_sym]
           save_into_index(table_name, record, index.name, index_value)
         end
+
       end
+#      puts record.to_yaml
     end
     def save_into_index(table_name,record,index_name,index_value)
       @indexes[table_name]||={}
@@ -67,10 +69,10 @@ module SdbDal
           return
         end
       end
-      index<<record
+      index << record
       @reverse_indexes[table_name]||={}
       @reverse_indexes[table_name][record["metadata%primary_key"]]||=[]
-      @reverse_indexes[table_name][record["metadata%primary_key"]]<<index
+      @reverse_indexes[table_name][record["metadata%primary_key"]] << index
     end
     def retrieve_from_index(table_name,index_name,index_value)
       return [] unless @indexes[table_name]
@@ -89,7 +91,7 @@ module SdbDal
       objects=query(table_name,attribute_descriptions,options)
       result=[]
       objects.each do | o|
-        result<<o[primary_key]
+        result << o[primary_key]
       end
       result
     end
@@ -163,7 +165,7 @@ module SdbDal
             end
           end
           if ok
-            result<<record
+            result << record
           end
           
         end
@@ -233,7 +235,7 @@ module SdbDal
       if key.is_a?( Array)
         flattened_key=""
         key.each do |key_part|
-          flattened_key<<CGI.escape(key_part.to_s)+"/"
+          flattened_key << CGI.escape(key_part.to_s)+"/"
         end
         return flattened_key[0..-2]
       else
@@ -251,4 +253,4 @@ module SdbDal
 
   end
 
-end
+end

data/lib/sdb_dal/repository.rb

@@ -2,7 +2,6 @@ module SdbDal
   $KCODE = 'u'
   require "aws_sdb"
   require "sdb_dal/storage.rb"
-  require 'ya2yaml'
   require File.dirname(__FILE__) +"/memory_repository.rb"
   require File.dirname(__FILE__) +"/domain_object_cache_item.rb"
 
@@ -36,7 +35,6 @@ module SdbDal
         @logger = Logger.new(STDOUT)
         @logger.level = Logger::ERROR
       end
-
       @sdb=AwsSdb::Service.new(:access_key_id=>aws_key_id,:secret_access_key=>aws_secret_key,:url=>"http://sdb.amazonaws.com",:logger=>@logger)
       @session_cache=MemoryRepository.new
     
@@ -131,7 +129,7 @@ module SdbDal
         rescue Exception => e
           s= "#{e.message}\n#{e.backtrace}"
           @logger.warn(s) if @logger
-       
+          puts e.to_yaml
           sleep(i*i)
         end
       end
@@ -201,10 +199,6 @@ module SdbDal
                 got_something=true
                 extend_query(query," ['#{key}' >= '#{escape_quotes(attribute_descriptions[key].format_for_sdb_single( value.greater_than_or_equal_to))}']")
               end
-              if value==false
-                got_something=true
-                extend_query(query," ['#{key}' != 'true' ]")
-              end
               if !got_something
                 extend_query(query," ['#{key}' = '#{escape_quotes( attribute_descriptions[key].format_for_sdb_single(value))}']")
               end
@@ -366,7 +360,7 @@ module SdbDal
     def sdb_query_with_attributes(table_name,query,max,token=nil)
 
       @logger.debug( "SDB query:#{table_name}(#{max}) : #{query}   #{token}"  ) if @logger
-      puts "#{table_name}  #{query}   (#{max}) #{token}"
+#      puts "#{table_name}  #{query}   (#{max}) #{token}"
       20.times do |i|
         begin
           return @sdb.query_with_attributes(make_domain_name(table_name),query,max,token)
@@ -416,4 +410,4 @@ module SdbDal
       @session_cache.clear
     end
   end
-end  
+end  

data/lib/sdb_dal/repository_factory.rb

@@ -4,7 +4,9 @@ require "sdb_dal/memory_repository.rb"
 module SdbDal
   class RepositoryFactory
     
-    
+    def self.instance=(repo)
+      @repository=repo
+    end    
     def self.instance(options={})
       if options and options.has_key?(:repository)
         return options[:repository]

data/lib/sdb_dal/sdb_formatter.rb

@@ -52,7 +52,7 @@ module SdbFormatter
     end
      def format_boolean(value)
         
-        return ((value == true) || (value==1))?'true':'false'
+        return ((value == true) || (value==1)) ? 'true' : 'false'
     end
      def format_integer(value)
          
@@ -116,4 +116,4 @@ module SdbFormatter
       return temp
     end
 end
-end
+end

data/lib/sdb_dal/storage.rb

@@ -13,21 +13,33 @@ class Storage
   @memcache_servers=nil
   @aws_key_id = nil
   @aws_secret_key = nil
-  attr_accessor :tokens 
+  attr_accessor :tokens
+  attr_accessor :memory_only
   def initialize( aws_key_id,
       aws_secret_key,
       memcache_servers,
-      tokens=[] )
+      tokens=[] ,
+      options={})
     @memcache_servers=memcache_servers
-    @aws_key_id=aws_key_id
-    @aws_secret_key=aws_secret_key
-    @tokens=tokens
+    if options.has_key?(:memory_only) and options[:memory_only]
+      self.memory_only=true
+    else
+      @aws_key_id=aws_key_id
+      @aws_secret_key=aws_secret_key
+      @tokens=tokens
+
+    end
+
+
     if @memcache_servers and @memcache_servers.length>0
      @cache= MemCache.new @memcache_servers, :namespace => 'my_namespace'
     end
   end
   
   def real_s3
+    if self.memory_only
+      raise "this is a memcache only storage.  there is no s3"
+    end
     unless @conn
       @conn = S3::AWSAuthConnection.new(@aws_key_id, @aws_secret_key,@tokens,false)
     end 
@@ -53,6 +65,9 @@ class Storage
   end
   def real_s3_get(bucket,key)
 
+    if self.memory_only
+      return nil
+    end
     20.times do |i|
       begin
         response=real_s3.get(bucket,key)
@@ -80,6 +95,8 @@ class Storage
     real_s3.create_bucket(bucket,headers)
   end
   def real_s3_put(bucket,key,object,attributes)
+
+    return if self.memory_only
 x=nil
     20.times do |i|
       begin
@@ -139,10 +156,12 @@ x=nil
     
   end
   def put(bucket,key,object,attributes={})
+
     real_s3_put(bucket,key,object,attributes)
     
-    #cache in memcache if not image
-    if !attributes || 
+    #cache in memcache if not media file
+    if   memory_only ||
+        !attributes ||
         !attributes.has_key?('Content-Type') || 
         (attributes['Content-Type'].index('image')!=0 && attributes['Content-Type'].index('audio')!=0  && attributes['Content-Type'].index('video')!=0   ) 
       if @cache
@@ -170,13 +189,13 @@ x=nil
   end
   def create_direct_url(bucket,key,time_to_live_minutes=60) 
      real_s3_query_auth.expires_in=time_to_live_minutes*60
-        real_s3_query_auth.get(bucket,key)
+     real_s3_query_auth.get(bucket,key)
        
 
   end
   def create_direct_url(bucket,key,time_to_live_minutes=60) 
      real_s3_query_auth.expires_in=time_to_live_minutes*60
-        real_s3_query_auth.get(bucket,key)
+     real_s3_query_auth.get(bucket,key)
        
 
   end

data/lib/sdb_dal/uuid.rb

@@ -0,0 +1,285 @@
+
+#
+# = uuid.rb - UUID generator
+#
+# Author:: Assaf Arkin  assaf@labnotes.org
+#          Eric Hodel drbrain@segment7.net
+# Documentation:: http://trac.labnotes.org/cgi-bin/trac.cgi/wiki/Ruby/UuidGenerator
+# Copyright:: Copyright (c) 2005-2008 Assaf Arkin, Eric Hodel
+# License:: MIT and/or Creative Commons Attribution-ShareAlike
+
+require 'fileutils'
+require 'thread'
+require 'tmpdir'
+
+require 'rubygems'
+require 'macaddr'
+
+
+##
+# = Generating UUIDs
+#
+# Call #generate to generate a new UUID. The method returns a string in one of
+# three formats. The default format is 36 characters long, and contains the 32
+# hexadecimal octets and hyphens separating the various value parts. The
+# <tt>:compact</tt> format omits the hyphens, while the <tt>:urn</tt> format
+# adds the <tt>:urn:uuid</tt> prefix.
+#
+# For example:
+#
+#   uuid = UUID.new
+#   
+#   10.times do
+#     p uuid.generate
+#   end
+#
+# = UUIDs in Brief
+#
+# UUID (universally unique identifier) are guaranteed to be unique across time
+# and space.
+#
+# A UUID is 128 bit long, and consists of a 60-bit time value, a 16-bit
+# sequence number and a 48-bit node identifier.
+#
+# The time value is taken from the system clock, and is monotonically
+# incrementing.  However, since it is possible to set the system clock
+# backward, a sequence number is added.  The sequence number is incremented
+# each time the UUID generator is started.  The combination guarantees that
+# identifiers created on the same machine are unique with a high degree of
+# probability.
+#
+# Note that due to the structure of the UUID and the use of sequence number,
+# there is no guarantee that UUID values themselves are monotonically
+# incrementing.  The UUID value cannot itself be used to sort based on order
+# of creation.
+#
+# To guarantee that UUIDs are unique across all machines in the network,
+# the IEEE 802 MAC address of the machine's network interface card is used as
+# the node identifier.
+#
+# For more information see {RFC 4122}[http://www.ietf.org/rfc/rfc4122.txt].
+module SdbDal
+
+class UUID
+
+  VERSION = '2.0.1'
+
+  ##
+  # Clock multiplier. Converts Time (resolution: seconds) to UUID clock
+  # (resolution: 10ns)
+  CLOCK_MULTIPLIER = 10000000
+
+  ##
+  # Clock gap is the number of ticks (resolution: 10ns) between two Ruby Time
+  # ticks.
+  CLOCK_GAPS = 100000
+
+  ##
+  # Version number stamped into the UUID to identify it as time-based.
+  VERSION_CLOCK = 0x0100
+
+  ##
+  # Formats supported by the UUID generator.
+  #
+  # <tt>:default</tt>:: Produces 36 characters, including hyphens separating
+  #                     the UUID value parts
+  # <tt>:compact</tt>:: Produces a 32 digits (hexadecimal) value with no
+  #                     hyphens
+  # <tt>:urn</tt>:: Adds the prefix <tt>urn:uuid:</tt> to the default format
+  FORMATS = {
+    :compact => '%08x%04x%04x%04x%012x',
+    :default => '%08x-%04x-%04x-%04x-%012x',
+    :urn     => 'urn:uuid:%08x-%04x-%04x-%04x-%012x',
+  }
+
+  ##
+  # MAC address (48 bits), sequence number and last clock
+  STATE_FILE_FORMAT = 'SLLQ'
+
+  @state_file = nil
+  @mode = nil
+  @uuid = nil
+
+  ##
+  # The access mode of the state file.  Set it with state_file.
+
+  def self.mode
+    @mode
+  end
+
+  ##
+  # Generates a new UUID string using +format+.  See FORMATS for a list of
+  # supported formats.
+
+  def self.generate(format = :default)
+    @uuid ||= new
+    @uuid.generate format
+  end
+
+  ##
+  # Creates an empty state file in /var/tmp/ruby-uuid or the windows common
+  # application data directory using mode 0644.  Call with a different mode
+  # before creating a UUID generator if you want to open access beyond your
+  # user by default.
+  #
+  # If the default state dir is not writable, UUID falls back to ~/.ruby-uuid.
+  #
+  # State files are not portable across machines.
+  def self.state_file(mode = 0644)
+    return @state_file if @state_file
+
+    @mode = mode
+
+    begin
+      require 'Win32API'
+
+      csidl_common_appdata = 0x0023
+      path = 0.chr * 260
+      get_folder_path = Win32API.new('shell32', 'SHGetFolderPath', 'LLLLP', 'L')
+      get_folder_path.call 0, csidl_common_appdata, 0, 1, path
+
+      state_dir = File.join(path.strip)
+    rescue LoadError
+      state_dir = File.join('', 'var', 'tmp')
+    end
+
+    if File.writable?(state_dir) then
+      @state_file = File.join(state_dir, 'ruby-uuid')
+    else
+      @state_file = File.expand_path(File.join('~', '.ruby-uuid'))
+    end
+
+    @state_file
+  end
+
+  ##
+  # Create a new UUID generator.  You really only need to do this once.
+  def initialize
+    @drift = 0
+    @last_clock = (Time.now.to_f * CLOCK_MULTIPLIER).to_i
+    @mutex = Mutex.new
+
+    if File.exist?(self.class.state_file) then
+      next_sequence
+    else
+      @mac = Mac.addr.gsub(/:|-/, '').hex & 0x7FFFFFFFFFFF
+      fail "Cannot determine MAC address from any available interface, tried with #{Mac.addr}" if @mac == 0
+      @sequence = rand 0x10000
+
+      open_lock 'w' do |io|
+        write_state io
+      end
+    end
+  end
+
+  ##
+  # Generates a new UUID string using +format+.  See FORMATS for a list of
+  # supported formats.
+  def generate(format = :default)
+    template = FORMATS[format]
+
+    raise ArgumentError, "invalid UUID format #{format.inspect}" unless template
+
+    # The clock must be monotonically increasing. The clock resolution is at
+    # best 100 ns (UUID spec), but practically may be lower (on my setup,
+    # around 1ms). If this method is called too fast, we don't have a
+    # monotonically increasing clock, so the solution is to just wait.
+    #
+    # It is possible for the clock to be adjusted backwards, in which case we
+    # would end up blocking for a long time. When backward clock is detected,
+    # we prevent duplicates by asking for a new sequence number and continue
+    # with the new clock.
+
+    clock = @mutex.synchronize do
+      clock = (Time.new.to_f * CLOCK_MULTIPLIER).to_i & 0xFFFFFFFFFFFFFFF0
+
+      if clock > @last_clock then
+        @drift = 0
+        @last_clock = clock
+      elsif clock == @last_clock then
+        drift = @drift += 1
+
+        if drift < 10000 then
+          @last_clock += 1
+        else
+          Thread.pass
+          nil
+        end
+      else
+        next_sequence
+        @last_clock = clock
+      end
+    end until clock
+
+    template % [
+        clock        & 0xFFFFFFFF,
+       (clock >> 32) & 0xFFFF,
+      ((clock >> 48) & 0xFFFF | VERSION_CLOCK),
+      @sequence      & 0xFFFF,
+      @mac           & 0xFFFFFFFFFFFF
+    ]
+  end
+
+  ##
+  # Updates the state file with a new sequence number.
+  def next_sequence
+    open_lock 'r+' do |io|
+      @mac, @sequence, @last_clock = read_state(io)
+
+      io.rewind
+      io.truncate 0
+
+      @sequence += 1
+
+      write_state io
+    end
+  rescue Errno::ENOENT
+    open_lock 'w' do |io|
+      write_state io
+    end
+  ensure
+    @last_clock = (Time.now.to_f * CLOCK_MULTIPLIER).to_i
+    @drift = 0
+  end
+
+  def inspect
+    mac = ("%012x" % @mac).scan(/[0-9a-f]{2}/).join(':')
+    "MAC: #{mac}  Sequence: #{@sequence}"
+  end
+
+protected
+
+  ##
+  # Open the state file with an exclusive lock and access mode +mode+.
+  def open_lock(mode)
+    File.open self.class.state_file, mode, self.class.mode do |io|
+      begin
+        io.flock File::LOCK_EX
+        yield io
+      ensure
+        io.flock File::LOCK_UN
+      end
+    end
+  end
+
+  ##
+  # Read the state from +io+
+  def read_state(io)
+    mac1, mac2, seq, last_clock = io.read(32).unpack(STATE_FILE_FORMAT)
+    mac = (mac1 << 32) + mac2
+
+    return mac, seq, last_clock
+  end
+
+
+  ##
+  # Write that state to +io+
+  def write_state(io)
+    mac2 =  @mac        & 0xffffffff
+    mac1 = (@mac >> 32) & 0xffff
+
+    io.write [mac1, mac2, @sequence, @last_clock].pack(STATE_FILE_FORMAT)
+  end
+  
+end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sdb_dal
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - David Knight
@@ -9,7 +9,7 @@ autorequire: sdb_dal
 bindir: bin
 cert_chain: []
 
-date: 2009-01-03 00:00:00 -08:00
+date: 2009-01-11 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -26,6 +26,7 @@ files:
 - ./lib/sdb_dal/acts_as_sdb_application.rb
 - ./lib/sdb_dal/and_condition.rb
 - ./lib/sdb_dal/attribute_range.rb
+- ./lib/sdb_dal/crypto.rb
 - ./lib/sdb_dal/domain_attribute_description.rb
 - ./lib/sdb_dal/domain_object.rb
 - ./lib/sdb_dal/domain_object_cache_item.rb
@@ -34,6 +35,7 @@ files:
 - ./lib/sdb_dal/index_description.rb
 - ./lib/sdb_dal/is_null_transform.rb
 - ./lib/sdb_dal/lazy_loading_text.rb
+- ./lib/sdb_dal/memcache_repository.rb
 - ./lib/sdb_dal/memory_repository.rb
 - ./lib/sdb_dal/memory_storage.rb
 - ./lib/sdb_dal/or_condition.rb
@@ -48,6 +50,7 @@ files:
 - ./lib/sdb_dal/storage.rb
 - ./lib/sdb_dal/tag_cloud.rb
 - ./lib/sdb_dal/tracker_description.rb
+- ./lib/sdb_dal/uuid.rb
 has_rdoc: false
 homepage: http://www.yahoo.com/
 post_install_message: