rhc 1.4.8 → 1.5.13

data/lib/rhc/rest/client.rb

@@ -6,7 +6,183 @@ require 'httpclient'
 
 module RHC
   module Rest
+
+    MAX_RETRIES = 5
+
+    #
+    # These are methods that belong to the API object but are
+    # callable from the client for convenience.
+    #
+    module ApiMethods
+      def add_domain(id)
+        debug "Adding domain #{id}"
+        @domains = nil
+        api.rest_method "ADD_DOMAIN", :id => id
+      end
+
+      def domains
+        debug "Getting all domains"
+        @domains ||= api.rest_method "LIST_DOMAINS"
+      end
+
+      def cartridges
+        debug "Getting all cartridges"
+        @cartridges ||= api.rest_method("LIST_CARTRIDGES", nil, :lazy_auth => true)
+      end
+
+      def user
+        debug "Getting user info"
+        @user ||= api.rest_method "GET_USER"
+      end
+
+      def sshkeys
+        debug "Finding all keys for #{user.login}"
+        user.keys
+      end
+
+      def add_key(name, key, content)
+        debug "Adding key #{key} for #{user.login}"
+        user.add_key name, key, content
+      end
+
+      def delete_key(name)
+        debug "Deleting key '#{name}'"
+        key = find_key(name)
+        key.destroy
+      end
+
+      #Find Domain by namesapce
+      def find_domain(id)
+        debug "Finding domain #{id}"
+        domains.each { |domain| return domain if domain.id == id }
+
+        raise DomainNotFoundException.new("Domain #{id} not found")
+      end
+
+      def find_application(domain, application, options={})
+        response = request({
+          :url => link_show_application_by_domain_name(domain, application),
+          :method => "GET",
+          :payload => options
+        })
+      end
+
+      def find_application_gear_groups(domain, application, options={})
+        response = request({
+          :url => link_show_application_by_domain_name(domain, application, "gear_groups"),
+          :method => "GET",
+          :payload => options
+        })
+      end
+
+      def link_show_application_by_domain_name(domain, application, *args)
+        [
+          api.links['LIST_DOMAINS']['href'],
+          domain,
+          "applications",
+          application,
+        ].concat(args).map{ |s| URI.escape(s) }.join("/")
+      end
+
+      #Find Cartridge by name or regex
+      def find_cartridges(name)
+        debug "Finding cartridge #{name}"
+        if name.is_a?(Hash)
+          regex = name[:regex]
+          type = name[:type]
+          name = name[:name]
+        end
+
+        filtered = Array.new
+        cartridges.each do |cart|
+          if regex
+            filtered.push(cart) if cart.name.match(regex) and (type.nil? or cart.type == type)
+          else
+            filtered.push(cart) if (name.nil? or cart.name == name) and (type.nil? or cart.type == type)
+          end
+        end
+        return filtered
+      end
+
+      #find Key by name
+      def find_key(name)
+        debug "Finding key #{name}"
+        user.find_key(name) or raise RHC::KeyNotFoundException.new("Key #{name} does not exist")
+      end
+
+      def sshkeys
+        logger.debug "Finding all keys for #{user.login}" if @mydebug
+        user.keys
+      end
+
+      def add_key(name, key, content)
+        logger.debug "Adding key #{key} for #{user.login}" if @mydebug
+        user.add_key name, key, content
+      end
+
+      def delete_key(name)
+        logger.debug "Deleting key '#{name}'" if @mydebug
+        key = find_key(name)
+        key.destroy
+      end
+
+      def supports_sessions?
+        api.supports? 'ADD_AUTHORIZATION'
+      end
+
+      def authorizations
+        raise AuthorizationsNotSupported unless supports_sessions?
+        api.rest_method 'LIST_AUTHORIZATIONS'
+      end
+
+      #
+      # Returns nil if creating sessions is not supported, raises on error, otherwise
+      # returns an Authorization object.
+      #
+      def new_session(options={})
+        if supports_sessions?
+          api.rest_method('ADD_AUTHORIZATION', {
+            :scope => 'session',
+            :note => "RHC/#{RHC::VERSION::STRING} (from #{Socket.gethostname rescue 'unknown'} on #{RUBY_PLATFORM})",
+            :reuse => true
+          }, options)
+        end
+      end
+
+      def add_authorization(options={})
+        raise AuthorizationsNotSupported unless supports_sessions?
+        api.rest_method('ADD_AUTHORIZATION', options, options)
+      end
+
+      def delete_authorizations
+        raise AuthorizationsNotSupported unless supports_sessions?
+        api.rest_method('LIST_AUTHORIZATIONS', nil, {:method => :delete})
+      end
+
+      def delete_authorization(token)
+        raise AuthorizationsNotSupported unless supports_sessions?
+        api.rest_method('SHOW_AUTHORIZATION', nil, {:method => :delete, :params => {':id' => token}})
+      end
+
+      def authorization_scope_list
+        raise AuthorizationsNotSupported unless supports_sessions?
+        link = api.links['ADD_AUTHORIZATION']
+        scope = link['optional_params'].find{ |h| h['name'] == 'scope' }
+        scope['description'].scan(/(?!\n)\*(.*?)\n(.*?)(?:\n|\Z)/m).inject([]) do |h, (a, b)|
+          h << [a.strip, b.strip] if a.present? && b.present?
+          h
+        end
+      end
+
+      def logout
+        #TODO logout
+        debug "Logout/Close client"
+      end
+      alias :close :logout
+    end
+
     class Client < Base
+      include ApiMethods
 
       # Keep the list of supported API versions here
       # The list may not necessarily be sorted; we will select the last
@@ -33,6 +209,12 @@ module RHC
         @preferred_api_versions ||= CLIENT_API_VERSIONS
         @debug ||= false
 
+        if options[:token]
+          self.headers[:authorization] = "Bearer #{options.delete(:token)}"
+          options.delete(:user)
+          options.delete(:password)
+        end
+
         @auth = options.delete(:auth)
 
         self.headers.merge!(options.delete(:headers)) if options[:headers]
@@ -45,17 +227,33 @@ module RHC
         @debug
       end
 
+      def url
+        @end_point
+      end
+
+      def api
+        @api ||= RHC::Rest::Api.new(self, @preferred_api_versions).tap do |api| 
+          self.current_api_version = api.api_version_negotiated
+        end
+      end
+
+      def api_version_negotiated
+        api
+        current_api_version
+      end
+
       def request(options, &block)
-        (0..(1.0/0.0)).each do |i|
+        (0..MAX_RETRIES).each do |i|
           begin
             client, args = new_request(options.dup)
+            auth = options[:auth] || self.auth
 
-            #debug "Request: #{client.object_id} #{args.inspect}\n-------------" if debug?
+            debug "Request #{args[0].to_s.upcase} #{args[1]}" if debug?
             response = client.request(*(args << true))
-            #debug "Response: #{response.status} #{response.headers.inspect}\n#{response.content}\n-------------" if debug? && response
+            debug "   code #{response.status}" if debug? && response
 
             next if retry_proxy(response, i, args, client)
-            auth.retry_auth?(response) and redo if auth
+            auth.retry_auth?(response, self) and next if auth
             handle_error!(response, args[1], client) unless response.ok?
 
             break (if block_given?
@@ -68,7 +266,7 @@ module RHC
               debug "Response: #{e.res.status} #{e.res.headers.inspect}\n#{e.res.content}\n-------------" if debug?
 
               next if retry_proxy(e.res, i, args, client)
-              auth.retry_auth?(e.res) and redo if auth
+              auth.retry_auth?(e.res, self) and next if auth
               handle_error!(e.res, args[1], client)
             end
             raise ConnectionException.new(
@@ -134,122 +332,14 @@ module RHC
         end
       end
 
-      def url
-        @end_point
-      end
-
-      def api
-        @api ||= RHC::Rest::Api.new(self, @preferred_api_versions)
-      end
-
-      def api_version_negotiated
-        api.api_version_negotiated
-      end
-
-      ################################################
-      # Delegate methods to API, should be moved there
-      # and then simply passed through.
-
-      def add_domain(id)
-        debug "Adding domain #{id}"
-        @domains = nil
-        api.rest_method "ADD_DOMAIN", :id => id
-      end
-
-      def domains
-        debug "Getting all domains"
-        @domains ||= api.rest_method "LIST_DOMAINS"
-      end
-
-      def cartridges
-        debug "Getting all cartridges"
-        @cartridges ||= api.rest_method("LIST_CARTRIDGES", nil, :lazy_auth => true)
-      end
-
-      def user
-        debug "Getting user info"
-        @user ||= api.rest_method "GET_USER"
-      end
-
-      def sshkeys
-        debug "Finding all keys for #{user.login}"
-        user.keys
-      end
-
-      def add_key(name, key, content)
-        debug "Adding key #{key} for #{user.login}"
-        user.add_key name, key, content
-      end
-
-      def delete_key(name)
-        debug "Deleting key '#{name}'"
-        key = find_key(name)
-        key.destroy
-      end
-
-      #Find Domain by namesapce
-      def find_domain(id)
-        debug "Finding domain #{id}"
-        domains.each { |domain| return domain if domain.id == id }
-
-        raise RHC::DomainNotFoundException.new("Domain #{id} does not exist")
-      end
-
-      #Find Cartridge by name or regex
-      def find_cartridges(name)
-        debug "Finding cartridge #{name}"
-        if name.is_a?(Hash)
-          regex = name[:regex]
-          type = name[:type]
-          name = name[:name]
-        end
-
-        filtered = Array.new
-        cartridges.each do |cart|
-          if regex
-            filtered.push(cart) if cart.name.match(regex) and (type.nil? or cart.type == type)
-          else
-            filtered.push(cart) if (name.nil? or cart.name == name) and (type.nil? or cart.type == type)
-          end
-        end
-        return filtered
-      end
-
-      #find Key by name
-      def find_key(name)
-        debug "Finding key #{name}"
-        user.find_key(name) or raise RHC::KeyNotFoundException.new("Key #{name} does not exist")
-      end
-
-      def sshkeys
-        logger.debug "Finding all keys for #{user.login}" if @mydebug
-        user.keys
-      end
-
-      def add_key(name, key, content)
-        logger.debug "Adding key #{key} for #{user.login}" if @mydebug
-        user.add_key name, key, content
-      end
-
-      def delete_key(name)
-        logger.debug "Deleting key '#{name}'" if @mydebug
-        key = find_key(name)
-        key.destroy
-      end
-
-      def logout
-        #TODO logout
-        debug "Logout/Close client"
-      end
-      alias :close :logout
-
       protected
         include RHC::Helpers
 
         attr_reader :auth
+        attr_accessor :current_api_version
         def headers
           @headers ||= {
-            'Accept' => 'application/json',
+            :accept => :json
           }
         end
 
@@ -303,18 +393,30 @@ module RHC
         def new_request(options)
           options.reverse_merge!(self.options)
 
+          options[:connect_timeout] ||= options[:timeout] || 120
+          options[:receive_timeout] ||= options[:timeout] || 0
+          options[:send_timeout] ||= options[:timeout] || 0
+          options[:timeout] = nil
+
+          if auth = options[:auth] || self.auth
+            auth.to_request(options)
+          end
+
           headers = (self.headers.to_a + (options.delete(:headers) || []).to_a).inject({}) do |h,(k,v)|
             v = "application/#{v}" if k == :accept && v.is_a?(Symbol)
             h[k.to_s.downcase.gsub(/_/, '-')] = v
             h
           end
 
-          options[:connect_timeout] ||= options[:timeout] || 120
-          options[:receive_timeout] ||= options[:timeout] || 0
-          options[:send_timeout] ||= options[:timeout] || 0
-          options[:timeout] = nil
+          user = options.delete(:user)
+          password = options.delete(:password)
+          if user
+            headers['Authorization'] ||= "Basic #{["#{user}:#{password}"].pack('m').tr("\n", '')}"
+          end
 
-          auth.to_request(options) if auth
+          modifiers = []
+          version = options.delete(:api_version) || current_api_version
+          modifiers << ";version=#{version}" if version
 
           query = options.delete(:query) || {}
           payload = options.delete(:payload)
@@ -324,11 +426,18 @@ module RHC
           else
             headers['content-type'] ||= begin
                 payload = payload.to_json unless payload.nil? || payload.is_a?(String)
-                'application/json'
+                "application/json#{modifiers.join}"
               end
           end
           query = nil if query.blank?
 
+          if headers['accept'] && modifiers.present?
+            headers['accept'] << modifiers.join
+          end
+
+          # remove all unnecessary options
+          options.delete(:lazy_auth)
+
           args = [options.delete(:method), options.delete(:url), query, payload, headers, true]
           [httpclient_for(options), args]
         end
@@ -360,6 +469,10 @@ module RHC
             data.map{ |json| Domain.new(json, self) }
           when 'domain'
             Domain.new(data, self)
+          when 'authorization'
+            Authorization.new(data, self)
+          when 'authorizations'
+            data.map{ |json| Authorization.new(json, self) }
           when 'applications'
             data.map{ |json| Application.new(json, self) }
           when 'application'
@@ -388,7 +501,7 @@ module RHC
           "The server did not respond correctly. This may be an issue "\
           "with the server configuration or with your connection to the "\
           "server (such as a Web proxy or firewall)."\
-          "#{client.proxy.present? ? " Please verify that your proxy server is working correctly (#{client.proxy}) and that you can access the OpenShift server #{url}" : "Please verify that you can access the OpenShift server #{url}"}"
+          "#{client.proxy.present? ? " Please verify that your proxy server is working correctly (#{client.proxy}) and that you can access the OpenShift server #{url}" : " Please verify that you can access the OpenShift server #{url}"}"
         end
 
         def handle_error!(response, url, client)
@@ -414,6 +527,14 @@ module RHC
           when 403
             raise RequestDeniedException, messages_to_error(messages) || "You are not authorized to perform this operation."
           when 404
+            if messages.length == 1
+              case messages.first['exit_code']
+              when 127
+                raise DomainNotFoundException, messages_to_error(messages) || generic_error_message(url, client)
+              when 101
+                raise ApplicationNotFoundException, messages_to_error(messages) || generic_error_message(url, client)
+              end
+            end
             raise ResourceNotFoundException, messages_to_error(messages) || generic_error_message(url, client)
           when 409
             raise_generic_error(url, client) if messages.empty?

data/lib/rhc/rest/domain.rb

@@ -44,21 +44,6 @@ module RHC
         rest_method "DELETE", :force => force
       end
       alias :delete :destroy
-
-      def find_application(name, options={})
-        if name.is_a?(Hash)
-          options = name.merge(options)
-          name = options[:name]
-        end
-        framework = options[:framework]
-
-        debug "Finding application :name => #{name}, :framework => #{framework}"
-        applications.each do |app|
-          return app if (name.nil? or app.name.downcase == name.downcase) and (framework.nil? or app.framework == framework)
-        end
-
-        raise RHC::ApplicationNotFoundException.new("Application #{name} does not exist")
-      end
     end
   end
 end

data/lib/rhc/rest/gear_group.rb

@@ -3,7 +3,6 @@ require 'rhc/rest/base'
 module RHC
   module Rest
     class GearGroup < Base
-      include Rest
       define_attr :gears, :cartridges
     end
   end

data/lib/rhc/rest/mock.rb

@@ -15,6 +15,10 @@ module RHC::Rest::Mock
 
   module Helpers
 
+    def mock_date_1
+      '2013-02-21T01:00:01Z'
+    end
+
     def mock_user
       "test_user"
     end
@@ -23,16 +27,33 @@ module RHC::Rest::Mock
       respond_to?(:user_auth) ? self.user_auth : {:user => username, :password => password}
     end
 
+    def credentials_for(with_auth)
+      if with_auth == true
+        [respond_to?(:username) ? self.username : mock_user, respond_to?(:password) ? self.password : mock_pass]
+      elsif with_auth
+        with_auth.values_at(:user, :password)
+      end
+    end
+
+    def expect_authorization(with_auth)
+      username, password = credentials_for(with_auth)
+      lambda{ |r|
+        !username || (r.headers['Authorization'] == "Basic #{["#{username}:#{password}"].pack('m').tr("\n", '')}")
+      }
+    end
+
     def stub_api_request(method, uri, with_auth=true)
-      stub_request(method, mock_href(uri, with_auth)).
-        with(&user_agent_header)
+      api = stub_request(method, mock_href(uri, with_auth))
+      api.with(&lambda{ |r| request.headers['Authorization'] == "Bearer #{with_auth[:token]}" }) if with_auth.respond_to?(:[]) && with_auth[:token]
+      api.with(&expect_authorization(with_auth))
+      api.with(&user_agent_header)
     end
 
-    def stub_api(auth=false)
+    def stub_api(auth=false, authorizations=false)
       stub_api_request(:get, 'broker/rest/api', auth).
         to_return({
           :body => {
-            :data => mock_response_links(mock_real_client_links),
+            :data => mock_response_links(authorizations ? mock_api_with_authorizations : mock_real_client_links),
             :supported_api_versions => [1.0, 1.1, 1.2, 1.3],
           }.to_json
         })
@@ -64,6 +85,37 @@ module RHC::Rest::Mock
         with(:body => hash_including({:id => name})).
         to_return(new_domain(name))
     end
+    def stub_authorizations
+      stub_api_request(:get, 'broker/rest/user/authorizations', mock_user_auth).
+        to_return({
+          :status => 200,
+          :body => {
+            :type => 'authorizations',
+            :data => [
+              {
+                :note => 'an_authorization',
+                :token => 'a_token_value',
+                :created_at => mock_date_1,
+                :expires_in_seconds => 60,
+                :scopes => 'session read'
+              }
+            ]
+          }.to_json
+        })
+    end
+    def stub_delete_authorizations
+      stub_api_request(:delete, 'broker/rest/user/authorizations', mock_user_auth).
+        to_return(:status => 204)
+    end
+    def stub_delete_authorization(token)
+      stub_api_request(:delete, "broker/rest/user/authorizations/#{token}", mock_user_auth).
+        to_return(:status => 204)
+    end
+    def stub_add_authorization(params)
+      stub_api_request(:post, 'broker/rest/user/authorizations', mock_user_auth).
+        with(:body => hash_including(params)).
+        to_return(new_authorization(params))
+    end
     def stub_no_keys
       stub_api_request(:get, 'broker/rest/user/keys', mock_user_auth).to_return(no_keys)
     end
@@ -118,7 +170,7 @@ module RHC::Rest::Mock
           }.to_json
         })
     end
-    def stub_one_application(domain_name, name)
+    def stub_one_application(domain_name, name, *args)
       stub_api_request(:get, "broker/rest/domains/#{domain_name}/applications", mock_user_auth).
         to_return({
           :body => {
@@ -133,7 +185,26 @@ module RHC::Rest::Mock
             }],
           }.to_json
         })
+      stub_relative_application(domain_name,name, *args)
     end
+
+    def stub_relative_application(domain_name, app_name, body = {}, status = 200)
+      url = client_links['LIST_DOMAINS']['relative'] rescue "broker/rest/domains"
+      stub_api_request(:any, "#{url}/#{domain_name}/applications/#{app_name}").
+        to_return({
+          :body   => {
+            :type => 'application',
+            :data => {
+              :domain_id         => domain_name,
+              :name              => app_name,
+              :id                => 1,
+              :links             => mock_response_links(mock_app_links(domain_name,app_name)),
+            }
+          }.merge(body).to_json,
+          :status => status
+        })
+    end
+
     def stub_simple_carts
       stub_api_request(:get, 'broker/rest/cartridges', mock_user_auth).to_return(simple_carts)
     end
@@ -206,6 +277,22 @@ module RHC::Rest::Mock
         }.to_json
       }
     end
+    def new_authorization(params)
+      {
+        :status => 201,
+        :body => {
+          :type => 'authorization',
+          :data => {
+            :note => params[:note],
+            :token => 'a_token_value',
+            :scopes => (params[:scope] || "userinfo").gsub(/,/, ' '),
+            :expires_in => (params[:expires_in] || 60).to_i,
+            :expires_in_seconds => (params[:expires_in] || 60).to_i,
+            :created_at => mock_date_1,
+          },
+        }.to_json
+      }
+    end
 
     def mock_pass
       "test pass"
@@ -218,16 +305,7 @@ module RHC::Rest::Mock
     # Creates consistent hrefs for testing
     def mock_href(relative="", with_auth=false)
       server = respond_to?(:server) ? self.server : mock_uri
-      uri_string =
-        if with_auth == true
-          username = respond_to?(:username) ? self.username : mock_user
-          password = respond_to?(:password) ? self.password : mock_pass
-          "#{username}:#{password}@#{mock_uri}"
-        elsif with_auth
-          "#{with_auth[:user]}:#{with_auth[:password]}@#{server}"
-        else
-          server
-        end
+      uri_string = server
       "https://#{uri_string}/#{relative}"
     end
 
@@ -242,7 +320,7 @@ module RHC::Rest::Mock
         # this is not used by the API classes.
         link_set[operation] = { 'href' => mock_href(href), 'method' => method, 'relative' => href }
       end
-      return link_set
+      link_set
     end
 
     def mock_app_links(domain_id='test_domain',app_id='test_app')
@@ -278,6 +356,13 @@ module RHC::Rest::Mock
        ['LIST_CARTRIDGES', "broker/rest/cartridges", 'GET'],
       ]
     end
+    def mock_api_with_authorizations
+      mock_real_client_links.concat([
+        ['LIST_AUTHORIZATIONS', "broker/rest/user/authorizations", 'GET'],
+        ['ADD_AUTHORIZATION',   "broker/rest/user/authorizations", 'POST'],
+        ['SHOW_AUTHORIZATION',  "broker/rest/user/authorizations/:id", 'GET'],
+      ])
+    end
 
     def mock_domain_links(domain_id='test_domain')
       [['ADD_APPLICATION',   "domains/#{domain_id}/apps/add", 'post'],
@@ -392,6 +477,23 @@ module RHC::Rest::Mock
     def delete_key(name)
       @user.keys.delete_if { |key| key.name == name }
     end
+
+    # Need to mock this since we are not registering HTTP requests when adding apps to the mock domain
+    def find_application(domain, name, options = {})
+      find_domain(domain).applications.each do |app|
+        return app if app.name.downcase == name.downcase
+      end
+
+      raise RHC::Rest::ApplicationNotFoundException.new("Application #{name} does not exist")
+    end
+
+    def find_application_gear_groups(domain, name, options = {})
+      find_domain(domain).applications.each do |app|
+        return app.gear_groups if app.name.downcase == name.downcase
+      end
+
+      raise RHC::Rest::ApplicationNotFoundException.new("Application #{name} does not exist")
+    end
   end
 
   class MockRestApi < RHC::Rest::Api

data/lib/rhc/rest/user.rb

@@ -17,7 +17,6 @@ module RHC
 
       #Find Key by name
       def find_key(name)
-        #TODO do a regex caomparison
         keys.detect { |key| key.name == name }
       end