cloudwow-not_relational 0.1.0

data/README.rdoc

@@ -0,0 +1,7 @@
+= not_relational
+
+not relational is a really good thing that you really want.
+
+== Copyright
+
+Copyright (c) 2009 David Knight. See LICENSE for details.

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 1
+:major: 0
+:minor: 1

data/lib/not_relational/acts_as_not_relational_application.rb

@@ -0,0 +1,11 @@
+module NotRelational
+  module ActsAsNotRelationalApplication
+    def self.included(base)
+      base.before_filter :prepare_repository
+    end
+    def prepare_repository
+      puts "prepare repo"
+      NotRelational::RepositoryFactory.instance.clear_session_cache
+    end
+  end
+end

data/lib/not_relational/and_condition.rb

@@ -0,0 +1,10 @@
+module NotRelational
+
+class AndCondition
+  def initialize
+    
+  end
+  
+end
+
+end

data/lib/not_relational/attribute_range.rb

@@ -0,0 +1,57 @@
+module NotRelational
+
+class AttributeRange
+  attr_accessor :less_than
+  attr_accessor :greater_than
+  attr_accessor :less_than_or_equal_to
+  attr_accessor :greater_than_or_equal_to
+  attr_accessor :attribute_description #if this exists we act on objects else we act on attributes
+  
+  def initialize(options)
+      
+    self.attribute_description=options[:attribute_description]
+      
+    self.less_than=options[:less_than]
+    self.greater_than=options[:greater_than]
+    self.less_than_or_equal_to=options[:less_than_or_equal_to]
+    self.greater_than_or_equal_to=options[:greater_than_or_equal_to]
+    
+  end
+  def matches?(arg)
+    value=arg
+    if self.attribute_description
+      #its an object so pull out the value
+      value=arg[attribute_description.name]
+    end
+    return false if value==nil
+    return false if self.less_than                && (value <=> self.less_than)               >-1
+    return false if self.less_than_or_equal_to    && (value <=> self.less_than_or_equal_to)   ==1
+    return false if self.greater_than             && (value<=>self.greater_than)              <1
+    return false if self.greater_than_or_equal_to &&(value<=>self.greater_than_or_equal_to)   ==-1
+    
+    return true
+  end
+  def to_sdb_query
+    query=''
+    if self.less_than 
+      query << "  '#{attribute_description.name}' < '#{ attribute_description.format_for_sdb( self.less_than)}'"
+    end
+    if self.greater_than  
+      query << ' and ' if query.length>0
+      query << "  '#{attribute_description.name}' > '#{ attribute_description.format_for_sdb( self.greater_than)}'"
+    end
+    if  self.less_than_or_equal_to 
+      query << ' and ' if query.length>0
+      query << "  '#{attribute_description.name}' <= '#{ attribute_description.format_for_sdb( self.less_than_or_equal_to)}'"
+    end
+    if  self.greater_than_or_equal_to 
+      query << ' and ' if query.length>0
+      query << "  '#{attribute_description.name}' >= '#{ attribute_description.format_for_sdb( self.greater_than_or_equal_to)}'"
+    end
+             
+    return  query
+  end
+  
+end
+  
+end

data/lib/not_relational/berkeley_repository.rb

@@ -0,0 +1,48 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+module NotRelational
+  class BerkeleyRepository
+    def initialize(
+        domain_name= nil,
+        clob_bucket= nil,
+        aws_key_id= nil,
+        aws_secret_key= nil,
+        memcache_servers = nil ,
+        dummy=nil,
+        append_table_to_domain=nil,
+        options={}
+      )
+
+    end
+    def pause
+    end
+
+    def clear_session_cache
+
+    end
+def save(table_name, primary_key, attributes,index_descriptions)
+end
+ def save_into_index(table_name,record,index_name,index_value)
+
+  end
+
+ def retrieve_from_index(table_name,index_name,index_value)
+ end
+
+  def query_ids(table_name,attribute_descriptions,options)
+
+  end
+
+     def query(table_name,attribute_descriptions,options)
+     end
+     def find_one(table_name, primary_key,attribute_descriptions)#, non_clob_attribute_names, clob_attribute_names)
+    end
+    def get_clob(table_name,primary_key,clob_name)
+    end
+    def destroy(table_name, primary_key)
+    end
+
+
+end
+end

data/lib/not_relational/configuration.rb

@@ -0,0 +1,111 @@
+require "openssl"
+
+
+module NotRelational
+  class Configuration
+  
+    attr_reader :repository_class
+    attr_reader :domain_prefix
+    attr_reader :clob_bucket
+    attr_reader :aws_key_id
+    attr_reader :aws_secret_key
+    attr_reader :memcache_servers
+    attr_reader :append_table_to_domain
+    attr_reader :fail_fast
+
+    attr_reader :cipher_key_file
+    attr_reader :cipher_iv_file
+
+    def self.singleton
+      @singleton ||= NotRelational::Configuration.new
+      return @singleton
+    end
+
+    def initialize()
+      not_relational_config=find_config_section
+
+      if not_relational_config
+        if not_relational_config.has_key?("repository_class")
+          @repository_class=eval  not_relational_config["repository_class"]
+        else
+          @repository_class=NotRelational::Repository
+        end
+        @domain_prefix= not_relational_config["domain_name_prefix"] || ""
+        @clob_bucket= not_relational_config["s3_clob_bucket"]
+        @aws_key_id = not_relational_config["aws_key_id"]
+        @aws_secret_key = not_relational_config["aws_secret_key"]
+        @memcache_servers= not_relational_config['memcache_servers']
+        @memcache_servers = memcache_servers.split(",") if memcache_servers
+
+        @append_table_to_domain=not_relational_config['append_table_to_domain']
+        @fail_fast=not_relational_config['fail_fast']
+
+        @cipher_key_file = not_relational_config['cipher_key_file']
+        @cipher_key_file ||= "./.cipher_key"
+        if @cipher_key_file and File.exists?(@cipher_key_file)
+           @cipher_key=File.open(@cipher_key_file).read
+        end
+
+        @cipher_iv_file ||= "./cipher_iv"
+        @cipher_iv_file=not_relational_config['cipher_iv_file']
+        if @cipher_iv_file and File.exists?(@cipher_iv_file)
+          @cipher_iv=File.open(@cipher_iv_file).read
+        end
+
+      end
+    end
+def  crypto
+  return @crypto if @crypto
+  options={}
+  if cipher_key
+    options[:cipher_key=]= cipher_key
+    options[:cipher_iv  ]= cipher_iv
+    @crypto=Crypto.new()
+  else
+    @crypto=Crypto.new
+    File.open(self.cipher_key_file,'w').write(@crypto.key)
+    File.open(self.cipher_iv_file,'w').write(@crypto.iv)
+  end
+end
+    def cipher_key
+      return @cipher_key
+    end
+
+    def cipher_iv
+      return @cipher_iv
+    end
+
+    def find_config_section
+      return $not_relational_config if $not_relational_config
+      config_file_path=nil
+      config_section=nil
+
+      #when using rails use config/database.yml
+      if Object.const_defined?(:RAILS_ROOT)  and ENV.has_key?('RAILS_ENV')
+        config_file_path =  File.join("#{RAILS_ROOT}","config","database.yml")
+
+        config_section =ENV['RAILS_ENV']+"_not_relational"
+
+
+
+      else
+        #when not using rails use try database.yml then try config/database.yml
+
+        if File.exists?("database.yml")
+
+          config_file_path = "database.yml"
+        elsif File.exists?(File.join("config", "database.yml"))
+          config_file_path = File.join("config", "database.yml")
+        end
+
+        config_section =(ENV['not_relational_ENV'] || "production")+"_not_relational"
+      end
+      if config_file_path and config_section
+        config_file = YAML.load(File.open( config_file_path))
+
+        $not_relational_config = config_file[config_section]
+      end
+      return $not_relational_config
+    end
+  end
+end

data/lib/not_relational/crypto.rb

@@ -0,0 +1,58 @@
+require "openssl"
+ 
+module NotRelational
+  class Crypto
+
+    attr_reader :key
+    attr_reader :iv
+    def initialize(options={})
+      @cipher = OpenSSL::Cipher::Cipher.new("AES-256-CBC")
+
+      @key=options[:cipher_key] if options.has_key?(:cipher_key)
+      @iv=options[:cipher_iv] if options.has_key?(:cipher_iv)
+
+      unless @key
+        key_dir=options[:key_dir] if options.has_key?(:key_dir)
+        key_dir ||="/tmp"
+    
+        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
+      end
+
+
+      unless @iv
+        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
+    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