rhc 1.2.7 → 1.3.8

data/lib/rhc/output_helpers.rb

@@ -30,98 +30,101 @@ module RHC
       not @issues.nil?
     end
 
-    #---------------------------
-    # Domain information
-    #---------------------------
-
-    # This is a little different because we don't want to recreate the display_app function
-    def display_domain(domain)
-      say "No domain exists.  You can use 'rhc domain create' to create a namespace for applications." and return unless domain
-      header "Applications in %s" % domain.id do
-        domain.applications.each do |a|
-          display_app(a,a.cartridges,a.scalable_carts.first)
-        end.blank? and say "No applications. You can use 'rhc app create' to create new applications."
-      end
-    end
-
     #---------------------------
     # Application information
     #---------------------------
-    def display_app(app,cartridges = nil,scalable_cart = nil)
-      heading = "%s @ %s" % [app.name, app.app_url]
+    def display_app(app,cartridges = nil)
+      heading = "%s @ %s (uuid: %s)" % [app.name, app.app_url, app.uuid]
       paragraph do
         header heading do
-          display_app_properties(app,:creation_time,:uuid,:gear_profile,:git_url,:ssh_url,:aliases)
+          section(:bottom => 1) do
+            display_app_properties(
+              app,
+              :creation_time,
+              :gear_info,
+              :git_url,
+              :initial_git_url,
+              :ssh_string,
+              :aliases)
+          end
           display_included_carts(cartridges) if cartridges
-          display_scaling_info(app,scalable_cart) if scalable_cart
         end
       end
     end
 
     def display_app_properties(app,*properties)
       say_table \
-        "Application Info",
+        nil,
         get_properties(app,*properties),
         :delete => true
     end
 
     def display_included_carts(carts)
-      properties = Hash[carts.map do |cart|
-        [cart.name,cart.connection_info]
-      end]
-
-      properties = "None" unless properties.present?
-
-      say_table \
-        "Cartridges",
-        properties,
-        :preserve_keys => true
+      carts.each do |c|
+        section(:bottom => 1) do
+          display_cart(c)
+        end
+      end
     end
 
-    def display_scaling_info(app,cart)
-      # Save these values for easier reuse
-      values = [:current_scale,:scales_from,:scales_to,:scales_with]
-      # Get the scaling properties we care about
-      properties = get_properties(cart,*values)
-      # Format the string for applications
-      properties = "Scaled x%d (minimum: %s, maximum: %s) with %s on %s gears" %
-        [properties.values_at(*values), app.gear_profile].flatten
+    def format_cart_header(cart)
+      [
+        cart.name, 
+        cart.name != cart.display_name ? "(#{cart.display_name})" : nil,
+      ].compact.join(' ')
+    end
 
-      say_table \
-        "Scaling Info",
-        properties
+    def format_scaling_info(scaling)
+      "x%d (minimum: %s, maximum: %s) on %s gears" %
+        [:current_scale, :scales_from, :scales_to, :gear_profile].map{ |key| format_value(key, scaling[key]) } if scaling
+    end
+    def format_cart_gears(cart)
+      if cart.scalable?
+        format_scaling_info(cart.scaling)
+      elsif cart.shares_gears?
+        "Located with #{cart.collocated_with.join(", ")}"
+      else
+        "%d %s" % [format_value(:current_scale, cart.current_scale), format_value(:gear_profile, cart.gear_profile)]
+      end
+    end
+    def format_gear_info(info)
+      "%d (defaults to %s)" %
+        [:gear_count, :gear_profile].map{ |key| format_value(key, info[key]) } if info
     end
 
     #---------------------------
     # Cartridge information
     #---------------------------
 
-    def display_cart(cart,properties = nil)
+    def display_cart(cart, *properties)
       @table_displayed = false
-      header cart.name do
-        display_cart_properties(cart,properties) if properties
-        display_cart_scaling_info(cart) if cart.scalable?
-        #  Commenting this out for US2438
-        # display_cart_storage_info(cart) if cart.additional_gear_storage > 0
-        display_no_info("cartridge") unless @table_displayed
-      end
-    end
-
-    def display_cart_properties(cart,properties)
-      # We need to actually access the cart because it's not a simple hash
-      properties = get_properties(cart,*properties.keys) do |prop|
-        cart.property(:cart_data,prop)["value"]
-      end
 
       say_table \
-        "Properties",
-        properties
+        format_cart_header(cart),
+        get_properties(cart, *properties).
+          concat([[cart.scalable? ? :scaling : :gears, format_cart_gears(cart)]]).
+          concat(cart.properties.map{ |p| ["#{table_heading(p['name'])}:", p['value']] }.sort{ |a,b| a[0] <=> b[0] }),
+        :delete => true
+      display_no_info("cartridge") unless @table_displayed
     end
 
-    def display_cart_scaling_info(cart)
-      say_table \
-        "Scaling Info",
-        get_properties(cart,:current_scale,:scales_from,:scales_to)
+    def display_key(key, *properties)
+      properties = [:fingerprint, :visible_to_ssh?] if properties.empty?
+      say_table(
+        properties.include?(:name) ? nil : format_key_header(key),
+        get_properties(key, *properties),
+        {
+          :delete => true,
+          :color => (:green if properties.include?(:visible_to_ssh?) && key.visible_to_ssh?),
+        }
+      )
+    end
+
+    def format_key_header(key)
+      [
+        key.name,
+        "(type: #{key.type})",
+      ].compact.join(' ')
     end
 
 =begin
@@ -147,91 +150,72 @@ module RHC
     def display_no_info(type)
       say_table \
         nil,
-        ["This #{type} has no information to show"]
+        [["This #{type} has no information to show"]]
     end
 
     private
       def say_table(heading,values,opts = {})
         @table_displayed = true
-        table = make_table(values,opts)
 
-        # Go through all the table rows
-        _proc = proc{
-          table.each do |s|
-            # Remove trailing = (like for cartridges list)
-            indent s.gsub(/\s*=\s*$/,'')
-          end
-        }
+        values = values.to_a if values.is_a? Hash
+        values.delete_if do |arr|
+          arr[0] = "#{table_heading(arr.first)}:" if arr[0].is_a? Symbol
+          opts[:delete] and arr.last.blank?
+        end
+
+        table = self.table(values)
+        table = table.map{ |s| color(s, opts[:color]) } if opts[:color]
 
         # Make sure we nest properly
         if heading
-          header heading do
-            _proc.call
+          header(heading, opts) do
+            say table
           end
         else
-          _proc.call
+          say table
         end
       end
 
       # This uses the array of properties to retrieve them from an object
       def get_properties(object,*properties)
-        Hash[properties.map do |prop|
+        properties.map do |prop|
           # Either send the property to the object or yield it
           value = block_given? ? yield(prop) : object.send(prop)
           # Some values (like date) need some special handling
-          value = format_value(prop,value)
 
-          [prop,value]
-        end]
+          [prop, format_value(prop,value)]
+        end
       end
 
       # Format some special values
       def format_value(prop,value)
         case prop
+        when :plan_id
+          case value
+          when 'freeshift' then 'FreeShift'
+          when 'megashift' then 'MegaShift'
+          else value && value.capitalize || nil
+          end
+        when :visible_to_ssh?
+          value || nil
         when :creation_time
           date(value)
         when :scales_from,:scales_to
-          (value == -1 ? "available gears" : value)
+          (value == -1 ? "available" : value)
+        when :gear_info
+          format_gear_info(value)
 =begin
 #  Commenting this out for US2438
         when :base_gear_storage,:additional_gear_storage
           ((value.nil? or value == 0) ? "None" : "#{value}GB")
 =end
         when :aliases
-          value.join ' '
+          value.join ', '
         else
-          value
-        end
-      end
-
-      # Make the rows for the table
-      #   If we pass a hash, it will manipulate it into a nice table
-      #   Arrays and single vars will just be passed back as arrays
-      def make_table(values,opts = {})
-        case values
-        when Hash
-          # Loop through the values in case we need to fix them
-          _values = values.inject({}) do |h,(k,v)|
-            # Format the keys based on the table_heading function
-            #  If we pass :preserve_keys, we leave them alone (like for cart names)
-            key = opts[:preserve_keys] ? k : table_heading(k)
-
-            # Replace empty or nil values with spaces
-            #  If we pass :delete, we assume those are not needed
-            if v.blank?
-              h[key] = "" unless opts[:delete]
-            else
-              h[key] = v.to_s
-            end
-            h
+          case value
+          when Array then value.join(', ')
+          else            value
           end
-          # Join the values into rows
-          table _values, :join => " = "
-          # Create a simple array
-        when Array
-          values
-        else
-          [values]
         end
       end
   end

data/lib/rhc/rest.rb

@@ -1,9 +1,10 @@
-require 'logger'
-require 'rest-client'
-
 module RHC
   module Rest
 
+    autoload :Base,        'rhc/rest/base'
+    autoload :Attributes,  'rhc/rest/attributes'
+
+    autoload :Api,         'rhc/rest/api'
     autoload :Application, 'rhc/rest/application'
     autoload :Cartridge,   'rhc/rest/cartridge'
     autoload :Client,      'rhc/rest/client'
@@ -14,7 +15,7 @@ module RHC
 
     class Exception < RuntimeError
       attr_reader :code
-      def initialize(message=nil, code=nil)
+      def initialize(message=nil, code=1)
         super(message)
         @code = (Integer(code) rescue code)
       end
@@ -48,6 +49,7 @@ module RHC
     #The server has not found anything matching the Request-URI or the
     #requested resource does not exist
     class ResourceNotFoundException < ClientErrorException; end
+    class ApiEndpointNotFound < ResourceNotFoundException; end
 
     #Exceptions thrown in case of an HTTP 422 is received.
     class ValidationException < ClientErrorException
@@ -75,208 +77,23 @@ module RHC
     #that authorization has been refused for those credentials. 
     class UnAuthorizedException < ClientErrorException; end
 
-    # Unreachable host, SSL Exception
+    # DEPRECATED Unreachable host, SSL Exception
     class ResourceAccessException < Exception; end
 
     #I/O Exceptions Connection timeouts, etc
     class ConnectionException < Exception; end
     class TimeoutException < ConnectionException; end
-  end
-
-
-  module Rest
-    #API_VERSION = '1.1'
-    @@headers = {:accept => :json}
-    #@@headers = {:accept => "application/json;version=#{RHC::Rest::VERSION}"}
-
-    def logger
-      Logger.new(STDOUT)
-    end
 
-    def parse_response(response)
-      result = RHC::Json.decode(response)
-      type = result['type']
-      data = result['data']
-      case type
-      when 'domains'
-        domains = Array.new
-        data.each do |domain_json|
-          domains.push(Domain.new(domain_json, debug?))
-        end
-        return domains
-      when 'domain'
-        return Domain.new(data, debug?)
-      when 'applications'
-        apps = Array.new
-        data.each do |app_json|
-          apps.push(Application.new(app_json, debug?))
-        end
-        return apps
-      when 'application'
-        app = Application.new(data, debug?)
-        result['messages'].each do |message|
-          app.add_message(message['text']) if message['field'].nil? or message['field'] == 'result'
-        end
-        return app
-      when 'cartridges'
-        carts = Array.new
-        data.each do |cart_json|
-          carts.push(Cartridge.new(cart_json, debug?))
-        end
-        return carts
-      when 'cartridge'
-        return Cartridge.new(data, debug?)
-      when 'user'
-        return User.new(data, debug?)
-      when 'keys'
-        keys = Array.new
-        data.each do |key_json|
-          keys.push(Key.new(key_json, debug?))
-        end
-        return keys
-      when 'key'
-        return Key.new(data, debug?)
-      when 'gear_groups'
-        gears = Array.new
-        data.each do |gear_json|
-          gears.push(GearGroup.new(gear_json, debug?))
-        end
-        return gears
-      else
-        data
+    class SSLConnectionFailed < ConnectionException
+      attr_reader :reason
+      def initialize(reason, message)
+        super message
+        @reason = reason
       end
     end
+    class CertificateVerificationFailed < SSLConnectionFailed; end
+    class SelfSignedCertificate < CertificateVerificationFailed; end
 
-    def new_request(options)
-      # user specified timeout takes presidence
-      options[:timeout] = $rest_timeout || options[:timeout]
-      options[:open_timeout] ||= (options[:timeout] || 4)
-
-      RestClient::Request.new options
-    end
-
-    def request(request, &block)
-      tried = 0
-      begin
-        debug "Request: #{request.inspect}" if debug?
-        begin
-          response = request.execute
-        ensure
-          debug "Response: #{response.inspect}" rescue nil if debug?
-        end
-        #set cookie
-        rh_sso = response.cookies['rh_sso']
-        if not rh_sso.nil?
-          @@headers["cookie"] = "rh_sso=#{rh_sso}"
-        end
-        if block_given? 
-          yield response
-        else
-          parse_response(response) unless response.nil? or response.code == 204
-        end
-      rescue RestClient::RequestTimeout => 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 RestClient::ServerBrokeConnection => e
-        raise ConnectionException.new(
-          "Connection to server got interrupted: #{e.message}")
-      rescue RestClient::BadGateway => e
-        debug "ERROR: Received bad gateway from server, will retry once if this is a GET" if debug?
-        retry if (tried += 1) < 2 && request.method.to_s.upcase == "GET"
-        raise ConnectionException.new(
-          "An error occurred while communicating with the server (#{e.message}). This problem may only be temporary."\
-          "#{RestClient.proxy.present? ? " Check that you have correctly specified your proxy server '#{RestClient.proxy}' as well as your OpenShift server '#{request.url}'." : " Check that you have correctly specified your OpenShift server '#{request.url}'."}")
-      rescue RestClient::ExceptionWithResponse => e
-        process_error_response(e.response, request.url)
-      rescue SocketError => e
-        raise ConnectionException.new(
-          "Unable to connect to the server (#{e.message})."\
-          "#{RestClient.proxy.present? ? " Check that you have correctly specified your proxy server '#{RestClient.proxy}' as well as your OpenShift server '#{request.url}'." : " Check that you have correctly specified your OpenShift server '#{request.url}'."}")
-      rescue => e
-        logger.debug e.backtrace.join("\n  ") if debug?
-        raise ResourceAccessException.new(
-          "Failed to access resource: #{e.message}")
-      end
-    end
-
-    def generic_error(url)
-      ServerErrorException.new(
-        "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)."\
-        "#{RestClient.proxy.present? ? " Please verify that your proxy server is working correctly (#{RestClient.proxy}) and that you can access the OpenShift server #{url}" : "Please verify that you can access the OpenShift server #{url}"}",
-        129)
-    end
-
-    def process_error_response(response, url=nil)
-      messages = []
-      parse_error = nil
-      begin
-        result = RHC::Json.decode(response)
-        messages = Array(result['messages'])
-      rescue => e
-        logger.debug "Response did not include a message from server: #{e.message}" if debug?
-        parse_error = generic_error(url)
-      end
-      case response.code
-      when 401
-        raise UnAuthorizedException, "Not authenticated"
-      when 403
-        messages.each do |message|
-          if message['severity'].upcase == "ERROR"
-            raise RequestDeniedException, message['text']
-          end
-        end
-        raise RequestDeniedException.new("Forbidden")
-      when 404
-        messages.each do |message|
-          if message['severity'].upcase == "ERROR"
-            raise ResourceNotFoundException, message['text']
-          end
-        end
-        raise ResourceNotFoundException.new(url)
-      when 409
-        messages.each do |message|
-          if message['severity'] and message['severity'].upcase == "ERROR"
-            raise ValidationException.new(message['text'], message['field'], message['exit_code'])
-          end
-        end
-      when 422
-        e = nil
-        messages.each do |message|
-          if e and e.field == message["field"]
-            e.message << " #{message["text"]}"
-          else
-            e = ValidationException.new(message["text"], message["field"], message["exit_code"])
-          end
-        end
-        raise e || parse_error || ValidationException.new('Not valid')
-      when 400
-        messages.each do |message|
-          if message['severity'].upcase == "ERROR"
-            raise ClientErrorException, message['text']
-          end
-        end
-      when 500
-        messages.each do |message|
-          if message['severity'].upcase == "ERROR"
-            raise ServerErrorException.new(message['text'], message["exit_code"] ? message["exit_code"].to_i : nil)
-          end
-        end
-      when 503
-        messages.each do |message|
-          if message['severity'].upcase == "ERROR"
-            raise ServiceUnavailableException, message['text']
-          end
-        end
-        raise ServiceUnavailableException
-      else
-        raise ServerErrorException, "Server returned an unexpected error code: #{response.code}"
-      end
-      raise parse_error || generic_error(url)
-    end
+    class SSLVersionRejected < SSLConnectionFailed; end
   end
 end