relishable 0.7 → 0.8

data/lib/relish/dynamo_helper.rb

@@ -13,11 +13,9 @@ class Relish
       @db ||= Fog::AWS::DynamoDB.new(:aws_access_key_id => @aws_access_key, :aws_secret_access_key => @aws_secret_key)
     end
 
-    def query_current_version(id)
-      response = db.query(@table_name, {:S => id}, :ConsistentRead => true, :Limit => 1, :ScanIndexForward => false)
-      if response.status != 200
-        raise('status: #{response.status}')
-      end
+    def query_current_version(id, *attrs)
+      opts = set_attrs_on_opts(attrs, :ConsistentRead => true, :Limit => 1, :ScanIndexForward => false)
+      response = db.query(@table_name, {:S => id}, opts)
       if response.body['Count'] == 1
         response.body['Items'].first
       end
@@ -25,39 +23,33 @@ class Relish
 
     def put_current_version(item)
       response = db.put_item(@table_name, item, {:Expected => {:id => {:Exists => false}, :version => {:Exists => false}}})
-      if response.status != 200
-        raise('status: #{response.status}')
-      end
     end
 
-    def get_version(id, version)
-      response = db.get_item(@table_name, {:HashKeyElement => {:S => id}, :RangeKeyElement => {:N => version}})
-      if response.status != 200
-        raise('status: #{response.status}')
-      end
+    def get_version(id, version, *attrs)
+      opts = set_attrs_on_opts(attrs)
+      response = db.get_item(@table_name, {:HashKeyElement => {:S => id}, :RangeKeyElement => {:N => version}}, opts)
       response.body['Item']
     end
 
     def put_version(id, version, item)
       response = db.put_item(@table_name, item, {:Expected => {:id => {:Value => {:S => id}}, :version => {:Value => {:N => version}}}})
-      if response.status != 200
-        raise('status: #{response.status}')
-      end
     end
 
     def put(item)
       response = db.put_item(@table_name, item)
-      if response.status != 200
-        raise('status: #{response.status}')
-      end
     end
 
     def query(id, consistent, limit)
       response = db.query(@table_name, {:S => id}, :ConsistentRead => consistent, :Limit => limit, :ScanIndexForward => false)
-      if response.status != 200
-        raise('status: #{response.status}')
-      end
       response.body['Items']
     end
+
+    private
+
+    def set_attrs_on_opts(attrs, opts = {})
+      attrs = Array(attrs)
+      opts[:AttributesToGet] = attrs unless attrs.empty?
+      opts
+    end
   end
 end

data/lib/relish/encryption_helper.rb

@@ -1,3 +1,4 @@
+require "relish/release"
 require "fernet"
 require "openssl"
 
@@ -11,41 +12,49 @@ class Relish
       @secrets = secrets
     end
 
+    def encrypt_env(env)
+      encrypt_key_with_secret("env", env, hmac_secrets.first)
+    end
+
+    def decrypt_env(encrypted_token)
+      try_decrypt_with_index(encrypted_token)[0]
+    end
+
+    def upgrade_env_encryption(encrypted_token)
+      if encrypted_token.nil? || encrypted_token == ""
+        return false, encrypted_token
+      end
+      env, i = try_decrypt_with_index(encrypted_token)
+      i == 0 ? [false, encrypted_token] : [true, encrypt_env(env)]
+    end
+
+    protected
+
     def hmac_secrets
       @hmac_secrets ||= @secrets.map do |secret|
         OpenSSL::HMAC.hexdigest('sha256', @static_secret, secret)
       end
     end
 
-    def encrypt_env(env)
-      encrypt_key_with_secret("env", env, hmac_secrets.first)
-    end
-
-    def decrypt_env(encrypted_token)
+    def try_decrypt_with_index(encrypted_token)
       hmac_secrets.each_with_index do |secret, i|
-        success, env = try_decrypt(secret, encrypted_token, "env")
+        success, env = try_decrypt_key(secret, encrypted_token, "env")
         if success
-          return env
+          return env, i
         end
       end
       raise RelishDecryptionFailed
     end
 
-    def try_decrypt(secret, encrypted_token, hash_key)
-      decrypt_key(secret, encrypted_token, hash_key)
-    rescue OpenSSL::Cipher::CipherError => e
-      return false, {}
-    end
-
-    protected
-
-    def decrypt_key(secret, encrypted_token, hash_key)
+    def try_decrypt_key(secret, encrypted_token, hash_key)
       verifier = Fernet.verifier(secret, encrypted_token)
       verifier.enforce_ttl = false
       unless verifier.valid?
-        return false, {}
+        return false, nil
       end
       [true, verifier.data[hash_key]]
+    rescue OpenSSL::Cipher::CipherError => e
+      return false, nil
     end
 
     def encrypt_key_with_secret(hash_key, value, secret)

data/lib/relish.rb

@@ -38,8 +38,8 @@ class Relish
     release
   end
 
-  def current(id)
-    item = @db.query_current_version(id)
+  def current(id, *attrs)
+    item = @db.query_current_version(id, *attrs)
     unless item.nil?
       release = Release.new
       release.item = item
@@ -47,8 +47,8 @@ class Relish
     end
   end
 
-  def read(id, version)
-    item = @db.get_version(id, version)
+  def read(id, version, *attrs)
+    item = @db.get_version(id, version, *attrs)
     unless item.nil?
       release = Release.new
       release.item = item

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: relishable
 version: !ruby/object:Gem::Version
-  version: '0.7'
+  version: '0.8'
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-10 00:00:00.000000000 Z
+date: 2012-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog