rhc 0.98.16 → 1.0.4

data/lib/rhc/output_helpers.rb

@@ -0,0 +1,213 @@
+module RHC
+  module OutputHelpers
+    # Issues collector collects a set of recoverable issues and steps to fix them
+    # for output at the end of a complex command
+    def add_issue(reason, commands_header, *commands)
+      @issues ||= []
+      issue = {:reason => reason,
+               :commands_header => commands_header,
+               :commands => commands}
+      @issues << issue
+    end
+
+    def format_issues(indent)
+      return nil unless issues?
+
+      indentation = " " * indent
+      reasons = ""
+      steps = ""
+
+      @issues.each_with_index do |issue, i|
+        reasons << "#{indentation}#{i+1}. #{issue[:reason].strip}\n"
+        steps << "#{indentation}#{i+1}. #{issue[:commands_header].strip}\n"
+        issue[:commands].each { |cmd| steps << "#{indentation}  $ #{cmd}\n" }
+      end
+
+      [reasons, steps]
+    end
+
+    def issues?
+      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]
+      paragraph do
+        header heading do
+          display_app_properties(app,:creation_time,:uuid,:gear_profile,:git_url,:ssh_url,:aliases)
+          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",
+        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
+    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
+
+      say_table \
+        "Scaling Info",
+        properties
+    end
+
+    #---------------------------
+    # Cartridge information
+    #---------------------------
+
+    def display_cart(cart,properties = nil)
+      @table_displayed = false
+      header cart.name do
+        display_cart_properties(cart,properties) if properties
+        display_cart_scaling_info(cart) if cart.scalable?
+        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
+    end
+
+    def display_cart_scaling_info(cart)
+      say_table \
+        "Scaling Info",
+        get_properties(cart,:current_scale,:scales_from,:scales_to)
+    end
+
+    #---------------------------
+    # Misc information
+    #---------------------------
+
+    def display_no_info(type)
+      say_table \
+        nil,
+        ["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
+        }
+
+        # Make sure we nest properly
+        if heading
+          header heading do
+            _proc.call
+          end
+        else
+          _proc.call
+        end
+      end
+
+      # This uses the array of properties to retrieve them from an object
+      def get_properties(object,*properties)
+        Hash[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]
+      end
+
+      # Format some special values
+      def format_value(prop,value)
+        case prop
+        when :creation_time
+          date(value)
+        when :scales_from,:scales_to
+          (value == -1 ? "available gears" : value)
+        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
+          end
+          # Join the values into rows
+          table _values, :join => " = "
+          # Create a simple array
+        when Array
+          values
+        else
+          [values]
+        end
+      end
+  end
+end

data/lib/rhc/rest/application.rb

@@ -1,94 +1,161 @@
+require 'uri'
+require 'rhc/rest/base'
 
 module RHC
   module Rest
-    class Application
+    class Application < Base
       include Rest
-      attr_reader :domain_id, :name, :creation_time, :uuid, :aliases, :git_url, :app_url, :gear_profile, :framework, 
-      :scalable, :health_check_path, :embedded, :gear_count, :ssh_url, :scale_min, :scale_max
-      def initialize(args)
-        #logger.debug args
-        @domain_id = args[:domain_id] || args["domain_id"]
-        @name = args[:name] || args["name"]
-        @creation_time = args[:creation_time] || args["creation_time"]
-        @uuid = args[:uuid] || args["uuid"]
-        @aliases = args[:aliases] || args["aliases"]
-        @git_url = args[:git_url] || args["git_url"]
-        @app_url = args[:app_url] || args["app_url"]
-        @gear_profile = args[:gear_profile] || args["gear_profile"]
-        @framework = args[:framework] || args["framework"]
-        @scalable = args[:scalable] || args["scalable"]
-        @health_check_path = args[:health_check_path] || args["health_check_path"]
-        @embedded = args[:embedded] || args["embedded"]
-        @gear_count = args[:gear_count] || args["gear_count"]
-        @ssh_url = args[:ssh_url] || args["ssh_url"]
-        @scale_min = args[:scale_min] || args["scale_min"]
-        @scale_max = args[:scale_max] || args["scale_max"]
-        @links = args[:links] || args["links"]
-        
-      end
-
-      #Add Cartridge
-      def add_cartridge(name)
-        logger.debug "Adding cartridge #{name}" if @mydebug
-        url = @links['ADD_CARTRIDGE']['href']
-        method =  @links['ADD_CARTRIDGE']['method']
-        payload = {:name => name}
-        request = new_request(:url => url, :method => method, :headers => @@headers, :payload => payload)
-        return request(request)
-      end
-
-      #Get all Cartridge for this applications
+
+      attr_reader :domain_id, :name, :creation_time, :uuid, :aliases,
+                  :git_url, :app_url, :gear_profile, :framework,
+                  :scalable, :health_check_path, :embedded, :gear_count,
+                  :ssh_url
+
+      # Query helper to say consistent with cartridge
+      def scalable?
+        scalable
+      end
+
+      def scalable_carts
+        return [] unless scalable?
+        carts = cartridges.select(&:scalable?)
+        scales_with = carts.map(&:scales_with)
+        carts.delete_if{|x| scales_with.include?(x.name)}
+      end
+
+      def add_cartridge(name, timeout=nil)
+        debug "Adding cartridge #{name}"
+        rest_method "ADD_CARTRIDGE", {:name => name}, timeout
+      end
+
       def cartridges
-        logger.debug "Getting all cartridges for application #{self.name}" if @mydebug
-        url = @links['LIST_CARTRIDGES']['href']
-        method =  @links['LIST_CARTRIDGES']['method']
-        request = new_request(:url => url, :method => method, :headers => @@headers)
-        return request(request)
+        debug "Getting all cartridges for application #{name}"
+        rest_method "LIST_CARTRIDGES"
+      end
+
+      def gear_groups
+        debug "Getting all gear groups for application #{name}"
+        rest_method "GET_GEAR_GROUPS"
+      end
+
+      def tidy
+        debug "Starting application #{name}"
+        rest_method 'TIDY', :event => "tidy"
       end
 
-      #Start Application
       def start
-        logger.debug "Starting application #{self.name}" if @mydebug
-        url = @links['START']['href']
-        method =  @links['START']['method']
-        payload = {:event=> "start"}
-        request = new_request(:url => url, :method => method, :headers => @@headers, :payload => payload)
-        return request(request)
+        debug "Starting application #{name}"
+        rest_method 'START', :event => "start"
       end
 
-      #Stop  Application
       def stop(force=false)
-        logger.debug "Stopping application #{self.name} force-#{force}" if @mydebug
-        url = @links['STOP']['href']
-        method =  @links['STOP']['method']
+        debug "Stopping application #{name} force-#{force}"
+
         if force
           payload = {:event=> "force-stop"}
         else
           payload = {:event=> "stop"}
         end
-        request = new_request(:url => url, :method => method, :headers => @@headers, :payload => payload)
-        return request(request)
+
+        rest_method "STOP", payload
       end
 
-      #Restart Application
       def restart
-        logger.debug "Restarting application #{self.name}" if @mydebug
-        url = @links['RESTART']['href']
-        method =  @links['RESTART']['method']
-        payload = {:event=> "restart"}
-        request = new_request(:url => url, :method => method, :headers => @@headers, :payload => payload)
-        return request(request)
+        debug "Restarting application #{name}"
+        rest_method "RESTART", :event => "restart"
       end
 
-      #Delete Application
       def destroy
-        logger.debug "Deleting application #{self.name}" if @mydebug
-        url = @links['DELETE']['href']
-        method =  @links['DELETE']['method']
-        request = new_request(:url => url, :method => method, :headers => @@headers)
-        return request(request)
+        debug "Deleting application #{name}"
+        rest_method "DELETE"
       end
       alias :delete :destroy
+
+      def reload
+        debug "Reload application #{name}"
+        rest_method "RELOAD", :event => "reload"
+      end
+
+      def threaddump
+        debug "Running thread dump for #{name}"
+        rest_method "THREAD_DUMP", :event => "thread-dump"
+      end
+
+      def add_alias(app_alias)
+        debug "Running add_alias for #{name}"
+        rest_method "ADD_ALIAS", :event => "add-alias", :alias => app_alias
+      end
+
+      def remove_alias(app_alias)
+        debug "Running add_alias for #{name}"
+        rest_method "REMOVE_ALIAS", :event => "remove-alias", :alias => app_alias
+      end
+
+      #Find Cartridge by name
+      def find_cartridge(sought, options={})
+        debug "Finding cartridge #{sought} in app #{name}"
+
+        type = options[:type]
+
+        cartridges.each { |cart| return cart if cart.name == sought and (type.nil? or cart.type == type) }
+
+        suggested_msg = ""
+        valid_cartridges = cartridges.select {|c| type.nil? or c.type == type}
+        unless valid_cartridges.empty?
+          suggested_msg = "\n\nValid cartridges:"
+          valid_cartridges.each { |cart| suggested_msg += "\n#{cart.name}" }
+        end
+        raise RHC::CartridgeNotFoundException.new("Cartridge #{sought} can't be found in application #{name}.#{suggested_msg}")
+      end
+
+      #Find Cartridges by name or regex
+      def find_cartridges(name, options={})
+        if name.is_a?(Hash)
+          options = name
+          name = options[:name]
+        end
+
+        type = options[:type]
+        regex = options[:regex]
+        debug "Finding cartridge #{name || regex} in app #{@name}"
+
+        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 cart.name == name and (type.nil? or cart.type == type)
+          end
+        end
+        filtered
+      end
+
+      def host
+        @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
+      end
     end
   end
 end

data/lib/rhc/rest/base.rb

@@ -0,0 +1,48 @@
+require 'base64'
+require 'rhc/json'
+
+module RHC
+  module Rest
+    class Base
+      include Rest
+
+      attr_reader :messages
+
+      def initialize(json_args={}, use_debug=false)
+        @debug = use_debug
+        @__json_args__ = json_args
+        @messages = []
+      end
+
+      def add_message(msg)
+        @messages << msg
+      end
+
+      private
+        def debug(msg)
+          logger.debug(msg) if @debug
+        end
+
+        def rest_method(link_name, payload={}, timeout=nil)
+          url = links[link_name]['href']
+          method =  links[link_name]['method']
+
+          request = new_request(:url => url, :method => method, :headers => @@headers, :payload => payload, :timeout => timeout)
+          debug "Request: #{request.inspect}"
+          request(request)
+        end
+
+        def links
+          @__json_args__[:links] || @__json_args__['links']
+        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
+        end
+    end
+  end
+end

data/lib/rhc/rest/cartridge.rb

@@ -1,12 +1,10 @@
+require 'rhc/rest/base'
+
 module RHC
   module Rest
-    class Cartridge
-      include Rest
-      attr_reader :type, :name, :properties
-      def initialize(args)
-        @name = args[:name] || args["name"]
-        @type = args[:type] || args["type"]
-        @links = args[:links] || args["links"]
+    class Cartridge < Base
+      attr_reader :type, :name, :properties, :status_messages, :scales_to, :scales_from, :scales_with, :current_scale
+      def initialize(args, use_debug=false)
         @properties = {}
         props = args[:properties] || args["properties"] || []
         props.each do |p|
@@ -14,63 +12,61 @@ module RHC
           category[:"#{p['name']}"] = p
           @properties[:"#{p['type']}"] = category
         end
+
+        super
+      end
+
+      def scalable?
+        [scales_to,scales_from].map{|x| x > 1 || x == -1}.inject(:|)
       end
 
       def property(category, key)
-         category = properties[category]
-         category ? category[key] : nil
+        category = properties[category]
+        category ? category[key] : nil
+      end
+
+      def status
+        debug "Getting cartridge #{name}'s status"
+        result = rest_method "GET", :include => "status_messages"
+        result.status_messages
       end
 
-      #Start Cartridge
       def start
-        logger.debug "Starting cartridge #{self.name}" if @mydebug
-        url = @links['START']['href']
-        method =  @links['START']['method']
-        payload = {:event=> "start"}
-        request = new_request(:url => url, :method => method, :headers => @@headers, :payload => payload)
-        return request(request)
+        debug "Starting cartridge #{name}"
+        rest_method "START", :event => "start"
       end
 
-      #Stop Cartridge
       def stop()
-        logger.debug "Stopping cartridge #{self.name}" if @mydebug
-        url = @links['STOP']['href']
-        method =  @links['STOP']['method']
-        payload = {:event=> "stop"}
-        request = new_request(:url => url, :method => method, :headers => @@headers, :payload => payload)
-        return request(request)
+        debug "Stopping cartridge #{name}"
+        rest_method "STOP", :event => "stop"
       end
 
-      #Restart Cartridge
       def restart
-        logger.debug "Restarting cartridge #{self.name}" if @mydebug
-        url = @links['RESTART']['href']
-        method =  @links['RESTART']['method']
-        payload = {:event=> "restart"}
-        request = new_request(:url => url, :method => method, :headers => @@headers, :payload => payload)
-        return request(request)
+        debug "Restarting cartridge #{name}"
+        rest_method "RESTART", :event => "restart"
       end
 
-      #Reload Cartridge
       def reload
-        logger.debug "Reloading cartridge #{self.name}" if @mydebug
-        url = @links['RESTART']['href']
-        method =  @links['RESTART']['method']
-        payload = {:event=> "reload"}
-        request = new_request(:url => url, :method => method, :headers => @@headers, :payload => payload)
-        return request(request)
+        debug "Reloading cartridge #{name}"
+        rest_method "RESTART", :event => "reload"
       end
 
-      #Delete Cartridge
       def destroy
-        logger.debug "Deleting cartridge #{self.name}" if @mydebug
-        url = @links['DELETE']['href']
-        method =  @links['DELETE']['method']
-        request = new_request(:url => url, :method => method, :headers => @@headers)
-        return request(request)
+        debug "Deleting cartridge #{name}"
+        rest_method "DELETE"
       end
       alias :delete :destroy
-      alias :delete :destroy
+
+      def set_scales(values)
+        values.delete_if{|k,v| v.nil? }
+        debug "Setting scales = %s" % values.map{|k,v| "#{k}: #{v}"}.join(" ")
+        rest_method "UPDATE", values
+      end
+
+      def connection_info
+        info = property(:cart_data, :connection_url) || property(:cart_data, :job_url) || property(:cart_data, :monitoring_url)
+        info ? (info["value"] || '').rstrip : nil
+      end
     end
   end
 end