rhc 1.2.7 → 1.3.8

data/lib/rhc/rest/api.rb

@@ -0,0 +1,88 @@
+module RHC
+  module Rest
+    class Api < Base
+      attr_reader :server_api_versions, :client_api_versions
+
+      def initialize(client, preferred_api_versions=[])
+        super(nil, client)
+
+        # API version negotiation
+        @server_api_versions = []
+        debug "Client supports API versions #{preferred_api_versions.join(', ')}"
+        @client_api_versions = preferred_api_versions
+        @server_api_versions, links = api_info({
+          :url => client.url,
+          :method => :get,
+          :lazy_auth => true,
+        })
+        debug "Server supports API versions #{@server_api_versions.join(', ')}"
+
+        if api_version_negotiated
+          unless server_api_version_current?
+            debug "Client API version #{api_version_negotiated} is not current. Refetching API"
+            # need to re-fetch API
+            @server_api_versions, links = api_info({
+              :url => client.url,
+              :method => :get,
+              :headers => {'Accept' => "application/json; version=#{api_version_negotiated}"},
+              :lazy_auth => true,
+            })
+          end
+        else
+          warn_about_api_versions
+        end
+
+        attributes['links'] = links
+
+      rescue RHC::Rest::ResourceNotFoundException => e
+        raise ApiEndpointNotFound.new(
+          "The OpenShift server is not responding correctly.  Check "\
+          "that '#{client.url}' is the correct URL for your server. "\
+          "The server may be offline or misconfigured.")
+      end
+
+      ### API version related methods
+      def api_version_match?
+        ! api_version_negotiated.nil?
+      end
+
+      # return the API version that the server and this client can agree on
+      def api_version_negotiated
+        client_api_versions.reverse. # choose the last API version listed
+          detect { |v| @server_api_versions.include? v }
+      end
+
+      def client_api_version_current?
+        current_client_api_version == api_version_negotiated
+      end
+
+      def current_client_api_version
+        client_api_versions.last
+      end
+
+      def server_api_version_current?
+        @server_api_versions && @server_api_versions.max == api_version_negotiated
+      end
+
+      def warn_about_api_versions
+        if !api_version_match?
+          warn "WARNING: API version mismatch. This client supports #{client_api_versions.join(', ')} but
+server at #{URI.parse(client.url).host} supports #{@server_api_versions.join(', ')}."
+          warn "The client version may be outdated; please consider updating 'rhc'. We will continue, but you may encounter problems."
+        end
+      end
+
+      protected
+        include RHC::Helpers
+
+      private
+        # execute +req+ with RestClient, and return [server_api_versions, links]
+        def api_info(req)
+          client.request(req) do |response|
+            json_response = ::RHC::Json.decode(response.content)
+            [ json_response['supported_api_versions'], json_response['data'] ]
+          end
+        end
+    end
+  end
+end

data/lib/rhc/rest/application.rb

@@ -1,15 +1,15 @@
 require 'uri'
-require 'rhc/rest/base'
 
 module RHC
   module Rest
     class Application < Base
       include Rest
 
-      attr_reader :domain_id, :name, :creation_time, :uuid, :aliases,
+      define_attr :domain_id, :name, :creation_time, :uuid, :aliases,
                   :git_url, :app_url, :gear_profile, :framework,
                   :scalable, :health_check_path, :embedded, :gear_count,
-                  :ssh_url
+                  :ssh_url, :building_app, :cartridges, :initial_git_url
+      alias_method :domain_name, :domain_id
 
       # Query helper to say consistent with cartridge
       def scalable?
@@ -23,14 +23,25 @@ module RHC
         carts.delete_if{|x| scales_with.include?(x.name)}
       end
 
-      def add_cartridge(name, timeout=nil)
+      def add_cartridge(name, options={})
         debug "Adding cartridge #{name}"
-        rest_method "ADD_CARTRIDGE", {:name => name}, timeout
+        @cartridges = nil
+        attributes['cartridges'] = nil
+        rest_method "ADD_CARTRIDGE", {:name => name}, options
       end
 
       def cartridges
         debug "Getting all cartridges for application #{name}"
-        rest_method "LIST_CARTRIDGES"
+        @cartridges ||=
+          unless (carts = attributes['cartridges']).nil?
+            carts.map{|x| Cartridge.new(x, client) }
+          else
+            rest_method "LIST_CARTRIDGES"
+          end
+      end
+
+      def gear_info
+        { :gear_count => gear_count, :gear_profile => gear_profile } unless gear_count.nil?
       end
 
       def gear_groups
@@ -87,7 +98,7 @@ module RHC
       end
 
       def remove_alias(app_alias)
-        debug "Running add_alias for #{name}"
+        debug "Running remove_alias for #{name}"
         rest_method "REMOVE_ALIAS", :event => "remove-alias", :alias => app_alias
       end
 
@@ -122,9 +133,9 @@ module RHC
         filtered = Array.new
         cartridges.each do |cart|
           if regex
-            filtered.push(cart) if cart.name.match(regex) and (type.nil? or cart.type == type)
+            filtered.push(cart) if cart.name.match(/(?i:#{regex})/) and (type.nil? or cart.type == type)
           else
-            filtered.push(cart) if cart.name == name and (type.nil? or cart.type == type)
+            filtered.push(cart) if cart.name.downcase == name.downcase and (type.nil? or cart.type == type)
           end
         end
         filtered
@@ -134,27 +145,15 @@ module RHC
         @host ||= URI(app_url).host
       end
 
-      #Application log file tailing
-      def tail(options)
-        debug "Tail in progress for #{name}"
-
-        file_glob = options.files ? options.files : "#{cartridges.first.name}/logs/*"
-        remote_cmd = "tail#{options.opts ? ' --opts ' + Base64::encode64(options.opts).chomp : ''} #{file_glob}"
-        ssh_cmd = "ssh -t #{uuid}@#{host} '#{remote_cmd}'"
-        begin
-          #Use ssh -t to tail the logs
-          debug ssh_cmd
-          ssh_ruby(host, uuid, remote_cmd)
-        rescue SocketError => e
-          msg =<<MESSAGE
-Could not connect: #{e.message}
-You can try to run this manually if you have ssh installed:
-#{ssh_cmd}
-
-MESSAGE
-          debug "DEBUG: #{e.message}\n"
-          raise SocketError, msg
-        end
+      def ssh_string
+        uri = URI(ssh_url)
+        "#{uri.user}@#{uri.host}"
+      end
+
+      def <=>(other)
+        c = name.downcase <=> other.name.downcase
+        return c unless c == 0
+        domain_id <=> other.domain_id
       end
     end
   end

data/lib/rhc/rest/attributes.rb

@@ -0,0 +1,27 @@
+module RHC::Rest::Attributes
+  def attributes
+    @attributes
+  end
+
+  def attributes=(attr=nil)
+    @attributes = (attr || {}).stringify_keys!
+  end
+
+  def attribute(name)
+    instance_variable_get("@#{name}") || attributes[name.to_s]
+  end
+end
+
+module RHC::Rest::AttributesClass
+  def define_attr(*names)
+    names.map(&:to_sym).each do |name|
+      define_method(name) do
+        attribute(name)
+      end
+      define_method("#{name}=") do |value|
+        instance_variable_set(:"@#{name}", nil)
+        attributes[name.to_s] = value
+      end
+    end
+  end
+end

data/lib/rhc/rest/base.rb

@@ -1,51 +1,47 @@
-require 'base64'
-require 'rhc/json'
-
 module RHC
   module Rest
     class Base
-      include Rest
+      include Attributes
+      extend AttributesClass
 
-      attr_reader :messages
+      define_attr :messages
 
-      def initialize(json_args={}, use_debug=false)
-        @debug = use_debug
-        @__json_args__ = json_args
-        @messages = []
+      def initialize(attrs=nil, client=nil)
+        @attributes = (attrs || {}).stringify_keys!
+        @attributes['messages'] ||= []
+        @client = client
       end
 
       def add_message(msg)
-        @messages << msg
+        messages << msg
       end
 
-      protected
-        def debug?
-          @debug
-        end
-
-      private
-        def debug(msg, obj=nil)
-          logger.debug("#{msg}#{obj ? " #{obj}" : ''}") if debug?
-        end
+      def rest_method(link_name, payload={}, options={})
+        link = links[link_name.to_s]
+        raise "No link defined for #{link_name}" unless link
+        url = link['href']
+        method = link['method']
+
+        client.request(options.merge({
+          :url => url,
+          :method => method,
+          :payload => payload,
+        }))
+      end
 
-        def rest_method(link_name, payload={}, timeout=nil)
-          url = links[link_name]['href']
-          method =  links[link_name]['method']
+      def links
+        attributes['links'] || {}
+      end
 
-          request = new_request(:url => url, :method => method, :headers => @@headers, :payload => payload, :timeout => timeout)
-          request(request)
-        end
+      protected
+        attr_reader :client
 
-        def links
-          @__json_args__[:links] || @__json_args__['links']
+        def debug(msg, obj=nil)
+          client.debug("#{msg}#{obj ? " #{obj}" : ''}") if client && client.debug?
         end
 
-        def self.attr_reader(*names)
-          names.each do |name|
-            define_method(name) do
-              instance_variable_get("@#{name}") || @__json_args__[name] || @__json_args__[name.to_s]
-            end
-          end
+        def debug?
+          client && client.debug?
         end
     end
   end

data/lib/rhc/rest/cartridge.rb

@@ -1,32 +1,48 @@
-require 'rhc/rest/base'
-
 module RHC
   module Rest
     class Cartridge < Base
-      attr_reader :type, :name, :display_name, :properties, :status_messages, :scales_to, :scales_from, :scales_with, :current_scale, :base_gear_storage, :additional_gear_storage
-      def initialize(args, use_debug=false)
-        @properties = {}
-        props = args[:properties] || args["properties"] || []
-        props.each do |p|
-          category = @properties[:"#{p['type']}"] || {}
-          category[:"#{p['name']}"] = p
-          @properties[:"#{p['type']}"] = category
-        end
+      HIDDEN_TAGS = [:framework, :web_framework, :cartridge].map(&:to_s)
 
-        # Make sure that additional gear storage is an integer
-        # TODO:  This should probably be fixed in the broker
-        args['additional_gear_storage'] = args['additional_gear_storage'].to_i rescue 0
+      define_attr :type, :name, :display_name, :properties, :gear_profile, :status_messages, :scales_to, :scales_from, :scales_with, :current_scale, :supported_scales_to, :supported_scales_from, :tags, :description, :collocated_with
 
-        super
+      def scalable?
+        supported_scales_to != supported_scales_from
       end
 
-      def scalable?
-        [scales_to,scales_from].map{|x| x > 1 || x == -1}.inject(:|)
+      def only_in_new?
+        type == 'standalone'
+      end
+      def shares_gears?
+        Array(collocated_with).present?
+      end
+      def collocated_with
+        Array(attribute(:collocated_with))
+      end
+
+      def tags
+        Array(attribute('tags'))
       end
 
-      def property(category, key)
-        category = properties[category]
-        category ? category[key] : nil
+      def additional_gear_storage
+        attribute(:additional_gear_storage).to_i rescue 0
+      end
+
+      def display_name
+        attribute(:display_name) || name
+      end
+
+      def scaling
+        {
+          :current_scale => current_scale,
+          :scales_from => scales_from,
+          :scales_to => scales_to,
+          :gear_profile => gear_profile,
+        } if scalable?
+      end
+
+      def property(type, key)
+        key, type = key.to_s, type.to_s
+        properties.select{ |p| p['type'] == type }.find{ |p| p['name'] == key }
       end
 
       def status
@@ -76,6 +92,12 @@ module RHC
         info = property(:cart_data, :connection_url) || property(:cart_data, :job_url) || property(:cart_data, :monitoring_url)
         info ? (info["value"] || '').rstrip : nil
       end
+
+      def <=>(other)
+        return -1 if other.type == 'standalone' && type != 'standalone'
+        return 1  if type == 'standalone' && other.type != 'standalone'
+        name <=> other.name
+      end
     end
   end
 end

data/lib/rhc/rest/client.rb

@@ -1,82 +1,174 @@
-require 'base64'
 require 'rhc/json'
-require 'rhc/rest/base'
 require 'rhc/helpers'
 require 'uri'
+require 'logger'
+require 'httpclient'
 
 module RHC
   module Rest
     class Client < Base
-      include RHC::Helpers
-      
-      attr_reader :server_api_versions, :client_api_versions
+
       # Keep the list of supported API versions here
       # The list may not necessarily be sorted; we will select the last
       # matching one supported by the server.
       # See #api_version_negotiated
       CLIENT_API_VERSIONS = [1.1, 1.2, 1.3]
-      
-      def initialize(end_point, username, password, use_debug=false, preferred_api_versions = CLIENT_API_VERSIONS)
-        @debug = use_debug
-        @end_point = end_point
-        @server_api_versions = []
-        debug "Connecting to #{end_point}"
-
-        credentials = nil
-        userpass = "#{username}:#{password}"
-        # :nocov: version dependent code
-        if RUBY_VERSION.to_f == 1.8
-          credentials = Base64.encode64(userpass).delete("\n")
-        else
-          credentials = Base64.strict_encode64(userpass)
-        end
-        # :nocov:
-        @@headers["Authorization"] = "Basic #{credentials}"
-        @@headers["User-Agent"] = RHC::Helpers.user_agent rescue nil
-        RestClient.proxy = URI.parse(ENV['http_proxy']).to_s if ENV['http_proxy']
-
-        # API version negotiation
-        begin
-          debug "Client supports API versions #{preferred_api_versions.join(', ')}"
-          @client_api_versions = preferred_api_versions
-          default_request = new_request(:url => @end_point, :method => :get, :headers => @@headers)
-          @server_api_versions, links = api_info(default_request)
-          debug "Server supports API versions #{@server_api_versions.join(', ')}"
-
-          if api_version_negotiated
-            unless server_api_version_current?
-              debug "Client API version #{api_version_negotiated} is not current. Refetching API"
-              # need to re-fetch API
-              @@headers["Accept"] = "application/json; version=#{api_version_negotiated}"
-              req = new_request(:url => @end_point, :method => :get, :headers => @@headers)
-              @server_api_versions, links = api_info req
-            end
+
+      def initialize(*args)
+        options = args[0].is_a?(Hash) && args[0] || {}
+        @end_point, @debug, @preferred_api_versions =
+          if options.empty?
+            options[:user] = args.delete_at(1)
+            options[:password] = args.delete_at(1)
+            args
           else
-            warn_about_api_versions
+            [
+              options.delete(:url) ||
+                (options[:server] && "https://#{options.delete(:server)}/broker/rest/api"), 
+              options.delete(:debug),
+              options.delete(:preferred_api_versions)
+            ]
+          end
+
+        @preferred_api_versions ||= CLIENT_API_VERSIONS
+        @debug ||= false
+
+        @auth = options.delete(:auth)
+
+        self.headers.merge!(options.delete(:headers)) if options[:headers]
+        self.options.merge!(options)
+
+        debug "Connecting to #{@end_point}"
+      end
+
+      def debug?
+        @debug
+      end
+
+      def request(options, &block)
+        (0..(1.0/0.0)).each do |i|
+          begin
+            client, args = new_request(options.dup)
+
+            #debug "Request: #{client.object_id} #{args.inspect}\n-------------" if debug?
+            response = client.request(*(args << true))
+            #debug "Response: #{response.status} #{response.headers.inspect}\n#{response.content}\n-------------" if debug? && response
+
+            next if retry_proxy(response, i, args, client)
+            auth.retry_auth?(response) and redo if auth
+            handle_error!(response, args[1], client) unless response.ok?
+
+            break (if block_given?
+                yield response
+              else
+                parse_response(response.content) unless response.nil? or response.code == 204
+              end)
+          rescue HTTPClient::BadResponseError => e
+            if e.res
+              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
+              handle_error!(e.res, args[1], client)
+            end
+            raise ConnectionException.new(
+              "An unexpected error occured when connecting to the server: #{e.message}")
+          rescue HTTPClient::TimeoutError => e
+            raise TimeoutException.new(
+              "Connection to server timed out. "\
+              "It is possible the operation finished without being able "\
+              "to report success. Use 'rhc domain show' or 'rhc app show' "\
+              "to see the status of your applications.")
+          rescue EOFError => e
+            raise ConnectionException.new(
+              "Connection to server got interrupted: #{e.message}")
+          rescue OpenSSL::SSL::SSLError => e
+            raise SelfSignedCertificate.new(
+              'self signed certificate',
+              "The server is using a self-signed certificate, which means that a secure connection can't be established '#{args[1]}'.\n\n"\
+              "You may disable certificate checks with the -k (or --insecure) option. Using this option means that your data is potentially visible to third parties.") if self_signed?
+            raise case e.message
+              when /self signed certificate/
+                CertificateVerificationFailed.new(
+                  e.message,
+                  "The server is using a self-signed certificate, which means that a secure connection can't be established '#{args[1]}'.\n\n"\
+                  "You may disable certificate checks with the -k (or --insecure) option. Using this option means that your data is potentially visible to third parties.")
+              when /certificate verify failed/
+                CertificateVerificationFailed.new(
+                  e.message,
+                  "The server's certificate could not be verified, which means that a secure connection can't be established to the server '#{args[1]}'.\n\n"\
+                  "If your server is using a self-signed certificate, you may disable certificate checks with the -k (or --insecure) option. Using this option means that your data is potentially visible to third parties.")
+              when /unable to get local issuer certificate/
+                SSLConnectionFailed.new(
+                  e.message,
+                  "The server's certificate could not be verified, which means that a secure connection can't be established to the server '#{args[1]}'.\n\n"\
+                  "You may need to specify your system CA certificate file with --ssl-ca-file=<path_to_file>. If your server is using a self-signed certificate, you may disable certificate checks with the -k (or --insecure) option. Using this option means that your data is potentially visible to third parties.")
+              when /^SSL_connect returned=1 errno=0 state=SSLv2\/v3 read server hello A/
+                SSLVersionRejected.new(
+                  e.message,
+                  "The server has rejected your connection attempt with an older SSL protocol.  Pass --ssl-version=sslv3 on the command line to connect to this server.")
+              when /^SSL_CTX_set_cipher_list:: no cipher match/
+                SSLVersionRejected.new(
+                  e.message,
+                  "The server has rejected your connection attempt because it does not support the requested SSL protocol version.\n\n"\
+                  "Check with the administrator for a valid SSL version to use and pass --ssl-version=<version> on the command line to connect to this server.")
+              else
+                SSLConnectionFailed.new(
+                  e.message,
+                  "A secure connection could not be established to the server (#{e.message}). You may disable secure connections to your server with the -k (or --insecure) option '#{args[1]}'.\n\n"\
+                  "If your server is using a self-signed certificate, you may disable certificate checks with the -k (or --insecure) option. Using this option means that your data is potentially visible to third parties.")
+              end
+          rescue SocketError => e
+            raise ConnectionException.new(
+              "Unable to connect to the server (#{e.message})."\
+              "#{client.proxy.present? ? " Check that you have correctly specified your proxy server '#{client.proxy}' as well as your OpenShift server '#{args[1]}'." : " Check that you have correctly specified your OpenShift server '#{args[0]}'."}")
+          rescue RHC::Rest::Exception
+            raise
+          rescue => e
+            if debug?
+              logger.debug "#{e.message} (#{e.class})"
+              logger.debug e.backtrace.join("\n  ")
+            end
+            raise ConnectionException.new("An unexpected error occured: #{e.message}").tap{ |n| n.set_backtrace(e.backtrace) }
           end
         end
+      end
+
+      def url
+        @end_point
+      end
 
-        super({:links => links}, use_debug)
+      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}"
-        rest_method "ADD_DOMAIN", :id => id
+        @domains = nil
+        api.rest_method "ADD_DOMAIN", :id => id
       end
 
       def domains
         debug "Getting all domains"
-        rest_method "LIST_DOMAINS"
+        @domains ||= api.rest_method "LIST_DOMAINS"
       end
 
       def cartridges
         debug "Getting all cartridges"
-        rest_method("LIST_CARTRIDGES")
+        @cartridges ||= api.rest_method("LIST_CARTRIDGES", nil, :lazy_auth => true)
       end
 
       def user
         debug "Getting user info"
-        rest_method "GET_USER"
+        @user ||= api.rest_method "GET_USER"
       end
 
       def sshkeys
@@ -150,51 +242,221 @@ module RHC
         debug "Logout/Close client"
       end
       alias :close :logout
-      
-      
-      ### API version related methods
-      def api_version_match?
-        ! api_version_negotiated.nil?
-      end
-      
-      # return the API version that the server and this client can agree on
-      def api_version_negotiated
-        client_api_versions.reverse. # choose the last API version listed
-          detect { |v| @server_api_versions.include? v }
-      end
-      
-      def client_api_version_current?
-        current_client_api_version == api_version_negotiated
-      end
-      
-      def current_client_api_version
-        client_api_versions.last
-      end
-      
-      def server_api_version_current?
-        @server_api_versions && @server_api_versions.max == api_version_negotiated
-      end
-      
-      def warn_about_api_versions
-        if !api_version_match?
-          warn "WARNING: API version mismatch. This client supports #{client_api_versions.join(', ')} but
-server at #{URI.parse(@end_point).host} supports #{@server_api_versions.join(', ')}."
-          warn "The client version may be outdated; please consider updating 'rhc'. We will continue, but you may encounter problems."
+
+      protected
+        include RHC::Helpers
+
+        attr_reader :auth
+        def headers
+          @headers ||= {
+            'Accept' => 'application/json',
+          }
         end
-      end
-      
-      def debug?
-        @debug
-      end
-      
+
+        def user_agent
+          RHC::Helpers.user_agent
+        end
+
+        def options
+          @options ||= {
+          }
+        end
+
+        def httpclient_for(options)
+          return @httpclient if @last_options == options
+          @httpclient = HTTPClient.new(:agent_name => user_agent).tap do |http|
+            http.cookie_manager = nil
+            http.debug_dev = $stderr if ENV['HTTP_DEBUG']
+
+            options.select{ |sym, value| http.respond_to?("#{sym}=") }.map{ |sym, value| http.send("#{sym}=", value) }
+            http.set_auth(nil, options[:user], options[:password]) if options[:user]
+
+            ssl = http.ssl_config
+            options.select{ |sym, value| ssl.respond_to?("#{sym}=") }.map{ |sym, value| ssl.send("#{sym}=", value) }
+            ssl.add_trust_ca(options[:ca_file]) if options[:ca_file]
+            ssl.verify_callback = default_verify_callback
+
+            @last_options = options
+          end
+        end
+
+        def default_verify_callback
+          lambda do |is_ok, ctx|
+            @self_signed = false
+            unless is_ok
+              cert = ctx.current_cert
+              if cert && (cert.subject.cmp(cert.issuer) == 0)
+                @self_signed = true
+                debug "SSL Verification failed -- Using self signed cert" if debug?
+              else
+                debug "SSL Verification failed -- Preverify: #{is_ok}, Error: #{ctx.error_string} (#{ctx.error})" if debug?
+              end
+              return false
+            end
+            true
+          end
+        end
+        def self_signed?
+          @self_signed
+        end
+
+        def new_request(options)
+          options.reverse_merge!(self.options)
+
+          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
+
+          auth.to_request(options) if auth
+
+          query = options.delete(:query) || {}
+          payload = options.delete(:payload)
+          if options[:method].to_s.upcase == 'GET'
+            query = payload
+            payload = nil
+          else
+            headers['content-type'] ||= begin
+                payload = payload.to_json unless payload.nil? || payload.is_a?(String)
+                'application/json'
+              end
+          end
+          query = nil if query.blank?
+
+          args = [options.delete(:method), options.delete(:url), query, payload, headers, true]
+          [httpclient_for(options), args]
+        end
+
+        def retry_proxy(response, i, args, client)
+          if response.status == 502
+            debug "ERROR: Received bad gateway from server, will retry once if this is a GET" if debug?
+            return true if i == 0 && args[0] == :get
+            raise ConnectionException.new(
+              "An error occurred while communicating with the server. This problem may only be temporary."\
+              "#{client.proxy.present? ? " Check that you have correctly specified your proxy server '#{client.proxy}' as well as your OpenShift server '#{args[1]}'." : " Check that you have correctly specified your OpenShift server '#{args[1]}'."}")
+          end
+        end
+
+        def parse_response(response)
+          result = RHC::Json.decode(response)
+          type = result['type']
+          data = result['data']
+
+          # Copy messages to each object
+          messages = Array(result['messages']).map do |m|
+            m['text'] if m['field'].nil? or m['field'] == 'result'
+          end.compact
+          data.each{ |d| d['messages'] = messages } if data.is_a?(Array)
+          data['messages'] = messages if data.is_a?(Hash)
+
+          case type
+          when 'domains'
+            data.map{ |json| Domain.new(json, self) }
+          when 'domain'
+            Domain.new(data, self)
+          when 'applications'
+            data.map{ |json| Application.new(json, self) }
+          when 'application'
+            Application.new(data, self)
+          when 'cartridges'
+            data.map{ |json| Cartridge.new(json, self) }
+          when 'cartridge'
+            Cartridge.new(data, self)
+          when 'user'
+            User.new(data, self)
+          when 'keys'
+            data.map{ |json| Key.new(json, self) }
+          when 'key'
+            Key.new(data, self)
+          when 'gear_groups'
+            data.map{ |json| GearGroup.new(json, self) }
+          else
+            data
+          end
+        end
+
+        def raise_generic_error(url, client)
+          raise ServerErrorException.new(generic_error_message(url, client), 129)
+        end
+        def generic_error_message(url, client)
+          "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}"}"
+        end
+
+        def handle_error!(response, url, client)
+          messages = []
+          parse_error = nil
+          begin
+            result = RHC::Json.decode(response.content)
+            messages = Array(result['messages'])
+            messages.delete_if do |m|
+              m.delete_if{ |k,v| k.nil? || v.blank? } if m.is_a? Hash
+              m.blank?
+            end
+          rescue => e
+            logger.debug "Response did not include a message from server: #{e.message}" if debug?
+          end
+          case response.status
+          when 400
+            raise_generic_error(url, client) if messages.empty?
+            message, keys = messages_to_fields(messages)
+            raise ValidationException.new(message || "The operation could not be completed.", keys)
+          when 401
+            raise UnAuthorizedException, "Not authenticated"
+          when 403
+            raise RequestDeniedException, messages_to_error(messages) || "You are not authorized to perform this operation."
+          when 404
+            raise ResourceNotFoundException, messages_to_error(messages) || generic_error_message(url, client)
+          when 409
+            raise_generic_error(url, client) if messages.empty?
+            message, keys = messages_to_fields(messages)
+            raise ValidationException.new(message || "The operation could not be completed.", keys)
+          when 422
+            raise_generic_error(url, client) if messages.empty?
+            message, keys = messages_to_fields(messages)
+            raise ValidationException.new(message || "The operation was not valid.", keys)
+          when 400
+            raise ClientErrorException, messages_to_error(messages) || "The server did not accept the requested operation."
+          when 500
+            raise ServerErrorException, messages_to_error(messages) || generic_error_message(url, client)
+          when 503
+            raise ServiceUnavailableException, messages_to_error(messages) || generic_error_message(url, client)
+          else
+            raise ServerErrorException, messages_to_error(messages) || "Server returned an unexpected error code: #{response.status}"
+          end
+          raise_generic_error
+        end
+
       private
-      # execute +req+ with RestClient, and return [server_api_versions, links]
-      def api_info(req)
-        request(req) do |response|
-          json_response = ::RHC::Json.decode(response)
-          [ json_response['supported_api_versions'], json_response['data'] ]
+        def logger
+          @logger ||= Logger.new(STDOUT)
+        end
+
+        def messages_to_error(messages)
+          errors, remaining = messages.partition{ |m| (m['severity'] || "").upcase == 'ERROR' }
+          if errors.present?
+            if errors.length == 1
+              errors.first['text']
+            else
+              "The server reported multiple errors:\n* #{errors.map{ |m| m['text'] || "An unknown server error occurred.#{ " (exit code: #{m['exit_code']}" if m['exit_code']}}" }.join("\n* ")}"
+            end
+          elsif remaining.present?
+            "The operation did not complete successfully, but the server returned additional information:\n* #{remaining.map{ |m| m['text'] || 'No message'}.join("\n* ")}"
+          end
+        end
+
+        def messages_to_fields(messages)
+          keys = messages.group_by{ |m| m['field'] }.keys.compact.sort.map(&:to_sym) rescue []
+          [messages_to_error(messages), keys]
         end
-      end
     end
   end
 end