conjur-api 2.2.2 → 2.2.3

data/lib/conjur-api/version.rb

@@ -1,5 +1,5 @@
 module Conjur
   class API
-    VERSION = "2.2.2"
+    VERSION = "2.2.3"
   end
 end

data/lib/conjur/base.rb

@@ -9,7 +9,6 @@ require 'conjur/escape'
 require 'conjur/log'
 require 'conjur/log_source'
 require 'conjur/standard_methods'
-require 'conjur/token_cache'
 
 module Conjur
   class API
@@ -58,7 +57,6 @@ module Conjur
       @username = username
       @api_key = api_key
       @token = token
-      TokenCache.store(@token) if token
 
       raise "Expecting ( username and api_key ) or token" unless ( username && api_key ) || token
     end
@@ -74,7 +72,7 @@ module Conjur
     end
     
     def token
-      TokenCache.fetch(username, api_key)
+      @token ||= Conjur::API.authenticate(@username, @api_key)
     end
     
     # Authenticate the username and api_key to obtain a request token.

data/spec/lib/api_spec.rb

@@ -110,33 +110,22 @@ describe Conjur::API do
     let(:login) { "bob" }
     let(:token) { { 'data' => login, 'timestamp' => (Time.now + elapsed ).to_s } }
     let(:elapsed) { 0 }
-    before {
-      Conjur::TokenCache.class_variable_set("@@tokens", Hash.new)
-    }
     subject { api }
     context "from token" do
       let(:api) { Conjur::API.new_from_token(token) }
-      context "expired" do
-        before {
-          Conjur::TokenCache.stub(:expired?).and_return true
-        }
-        it "should raise an error" do
-          $stderr.should_receive(:puts).with("Token will soon expire and no api_key is available to renew it")
-          
-          api.credentials
-        end
-      end
-      context "not expired" do
-        its(:credentials) { should == { headers: { authorization: "Token token=\"#{Base64.strict_encode64(token.to_json)}\"" }, username: login } }
-      end
+      subject { api }
+      its(:token) { should == token }
+      its(:credentials) { should == { headers: { authorization: "Token token=\"#{Base64.strict_encode64(token.to_json)}\"" }, username: login } }
     end
     context "from api key" do
       let(:api_key) { "theapikey" }
       let(:api) { Conjur::API.new_from_key(login, api_key) }
+      subject { api }
       it("should authenticate to get a token") do
         Conjur::API.should_receive(:authenticate).with(login, api_key).and_return token
         
         api.instance_variable_get("@token").should == nil
+        api.token.should == token
         api.credentials.should == { headers: { authorization: "Token token=\"#{Base64.strict_encode64(token.to_json)}\"" }, username: login }
       end
     end

data/spec/lib/role_spec.rb

@@ -10,13 +10,13 @@ describe Conjur::Role do
   let(:account) { "the-account" }
   context "#new" do
     let(:kind) { "test" }
-    let(:role) { Conjur::API.new_from_key('the-user', 'the-key').role([ account, kind, id ].join(":")) }
-    let(:token) { 'the-token' }
-    before {
-      Conjur::TokenCache.stub(:fetch).and_return token
-    }
+    let(:role) { Conjur::API.new_from_token({ 'data' => 'the-login' }).role([ account, kind, id ].join(":")) }
     context "with plain id" do
       let(:id) { "foo" }
+      context "credentials" do
+        subject { role }
+        its(:options) { should == {:headers=>{:authorization=>"Token token=\"eyJkYXRhIjoidGhlLWxvZ2luIn0=\""}, :username=>'the-login'} }
+      end
       it_should_behave_like "properties"
     end
     context "with more complex id" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: conjur-api
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.2.3
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-23 00:00:00.000000000 Z
+date: 2013-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -182,7 +182,6 @@ files:
 - lib/conjur/role_grant.rb
 - lib/conjur/secret.rb
 - lib/conjur/standard_methods.rb
-- lib/conjur/token_cache.rb
 - lib/conjur/user.rb
 - lib/conjur/variable.rb
 - spec/lib/api_spec.rb
@@ -209,7 +208,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2465680462875231923
+      hash: -3721927865223886977
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -218,7 +217,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2465680462875231923
+      hash: -3721927865223886977
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24

data/lib/conjur/token_cache.rb

@@ -1,41 +0,0 @@
-module Conjur
-  # Cache API tokens. The cache key is the authentication hostname and the username.
-  # Tokens are cached for a short period of time; long enough to save on server trips
-  # but not long enough to worry about tokens expiring.
-  class TokenCache
-    @@tokens = Hash.new
-    
-    class << self
-      def fetch(username, api_key)
-        key = [ Conjur::Authn::API.host, username ]
-        token = @@tokens[key]
-        if token.nil? || expired?(token)
-          if username && api_key
-            store(token = Conjur::API.authenticate(username, api_key))
-          elsif token.nil?
-            raise "Token is nil and no api_key is available to create it"
-          else
-            $stderr.puts "Token will soon expire and no api_key is available to renew it"
-          end
-        end
-        token
-      end
-      
-      def store(token)
-        username = token['data']
-        raise "No data in token" unless username
-        raise "Expecting string username in token" unless username.is_a?(String)
-        key = [ Conjur::Authn::API.host, username ]
-        @@tokens[key] = token
-      end
-      
-      protected
-      
-      # Expire tokens after 1 minute, even though they are valid for longer.
-      def expired?(token, expiry = 1 * 60)
-        raise "No timestamp in token" unless token['timestamp']
-        Time.parse(token["timestamp"]) + expiry < Time.now
-      end
-    end
-  end
-end