rhc 1.4.8 → 1.5.13

data/features/application.feature

@@ -19,6 +19,7 @@ Feature: Application Operations
       | running | snapshot  | the snapshot    | be found |
       | running | tidied    | it              | succeed |
       | running | shown     | it              | succeed |
+      | running | visualized| it              | succeed |
       | running | stopped   | the application | not be accessible |
       | stopped | started   | the application | be accessible |
       # After the app is deleted, it is resolving to the OpenShift server

data/features/lib/rhc_helper/app.rb

@@ -36,9 +36,11 @@ module RHCHelper
       # Setup questions asked by wizard which are passed in below:
       #   1 - username
       #   2 - password
-      #   3 - upload SSH keys
+      #   3 - should we support an api token, if server supports it
+      #   4 - upload SSH keys
       #   4 - if no namespace is found, create namespace? (blank is no)
       args = [$username, $password]
+      args << 'no' if $supports_auth_tokens
       args << 'yes' unless ($keyed_users ||= []).include?($username)
       args << '' # always skip namespace
       if $namespace
@@ -103,9 +105,9 @@ module RHCHelper
 
     # Get a REST client to verify the application is on the server
     def is_created?
-      new_client.domains[0].find_application(name)
+      new_client.find_application($namespace,name)
       true
-    rescue RHC::ApplicationNotFoundException
+    rescue RHC::Rest::ApplicationNotFoundException
       false
     end
 

data/features/lib/rhc_helper/commandify.rb

@@ -43,8 +43,9 @@ module RHCHelper
       cmd.gsub!('add alias', 'add-alias')
       cmd.gsub!('remove alias', 'remove-alias')
       cmd.gsub!('force stop', 'force-stop')
+      cmd.gsub!('show gears', 'show --gears')
 
-      return cmd
+      cmd
     end
 
     # Print out the command arguments based on the state of the application instance

data/features/step_definitions/application_steps.rb

@@ -70,7 +70,8 @@ When /^the application is (\w+)$/ do |command|
     :shown   => :show,
     :tidied  => :tidy,
     :snapshot => :snapshot_save,
-    :deleted => :delete
+    :deleted => :delete,
+    :visualized => :show_gears,
   }
 
   # Use an alias if it exists, or just remove 'ed' (like from started)

data/features/support/env.rb

@@ -67,7 +67,7 @@ set_endpoint
 raise "Username not found in environment (RHC_USERNAME)" unless $username
 raise "Password not found in environment (RHC_PASSWORD)" unless $password
 
-$user_register_script_format = "/usr/bin/ss-register-user -l admin -p admin --username %s --userpass %s"
+$user_register_script_format = "oo-register-user -l admin -p admin --username %s --userpass %s"
 if ENV['REGISTER_USER']
   command = $user_register_script_format % [$username,$password]
   %x[#{command}]
@@ -97,6 +97,9 @@ def clean_applications(leave_domain = false)
   $namespace = nil unless leave_domain
   $keyed_users = []
 
+  client = RHC::Rest::Client.new(:url => $end_point, :user => $username, :password => $password, :verify_mode => OpenSSL::SSL::VERIFY_NONE)
+  $supports_auth_tokens = client.supports_sessions?
+
   users.each do |user|
     _log "\tUser: #{user}"
     client = RHC::Rest::Client.new(:url => $end_point, :user => user, :password => $password, :verify_mode => OpenSSL::SSL::VERIFY_NONE)

data/lib/rhc/auth/basic.rb

@@ -1,7 +1,5 @@
 module RHC::Auth
   class Basic
-    attr_reader :cookie
-
     def initialize(*args)
       if args[0].is_a?(String) or args.length > 1
         @username, @password = args
@@ -15,30 +13,37 @@ module RHC::Auth
     end
 
     def to_request(request)
-      (request[:cookies] ||= {})[:rh_sso] = cookie if cookie
       request[:user] ||= username || (request[:lazy_auth] != true && ask_username) || nil
       request[:password] ||= password || (username? && request[:lazy_auth] != true && ask_password) || nil
       request
     end
 
-    def retry_auth?(response)
+    def retry_auth?(response, client)
       if response.status == 401
-        @cookie = nil
-        error "Username or password is not correct" if username? && password
-        unless @skip_interactive or @no_interactive
-          ask_username unless username?
-          ask_password
-          true
-        end
+        credentials_rejected
       else
-        @cookie ||= Array(response.cookies).inject(nil){ |v, c| c.name == 'rh_sso' ? c.value : v }
         false
       end
     end
 
+    def can_authenticate?
+      username? and not (password.nil? and @skip_interactive and @no_interactive)
+    end
+
+    attr_reader :username
+
     protected
       include RHC::Helpers
-      attr_reader :options, :username, :password
+      attr_reader :options, :password
+
+      def credentials_rejected
+        error "Username or password is not correct" if username? && password
+        unless @skip_interactive or @no_interactive
+          ask_username unless username?
+          ask_password
+          true
+        end
+      end
 
       def ask_username
         @username = ask("Login to #{openshift_server}: ") unless @no_interactive

data/lib/rhc/auth/token.rb

@@ -0,0 +1,98 @@
+module RHC::Auth
+  class Token
+    def initialize(opt, auth=nil, store=nil)
+      if opt.is_a?(String)
+        @token = opt
+      else
+        @options = opt || Commander::Command::Options.new
+        @token = options[:token]
+        @no_interactive = options[:noprompt]
+        @allows_tokens = options[:use_authorization_tokens]
+      end
+      @auth = auth
+      @store = store
+      read_token
+    end
+
+    def to_request(request)
+      if token
+        (request[:headers] ||= {})['authorization'] = "Bearer #{token}"
+      elsif auth and (!@allows_tokens or @can_get_token == false)
+        auth.to_request(request)
+      end
+      request
+    end
+
+    def retry_auth?(response, client)
+      if response.status == 401
+        token_rejected(response, client)
+      else
+        false
+      end
+    end
+
+    def username
+      auth && auth.respond_to?(:username) && auth.username || options[:username]
+    end
+
+    def save(token)
+      store.put(username, openshift_server, token) if store
+      @token = token
+    end
+
+    def can_authenticate?
+      token || auth && auth.can_authenticate?
+    end
+
+    protected
+      include RHC::Helpers
+      attr_reader :options, :token, :auth, :store
+
+      def token_rejected(response, client)
+        has_token = !!token
+        @token = nil
+
+        unless auth && auth.can_authenticate?
+          if has_token
+            raise RHC::Rest::TokenExpiredOrInvalid, "Your authorization token is expired or invalid."
+          end
+          return false
+        end
+
+        if has_token
+          if cannot_retry?
+            raise RHC::Rest::TokenExpiredOrInvalid, "Your authorization token is expired or invalid."
+          end
+          if not client.supports_sessions?
+            raise RHC::Rest::AuthorizationsNotSupported
+          end
+        end
+
+        @can_get_token = client.supports_sessions? && @allows_tokens
+
+        if has_token
+          warn "Your authorization token has expired. Please sign in now to continue."
+        elsif @can_get_token
+          info "Please sign in to start a new session to #{openshift_server}."
+        end
+
+        return auth.retry_auth?(response, client) unless @can_get_token
+
+        if auth_token = client.new_session(:auth => auth)
+          @fetch_once = true
+          save(auth_token.token)
+          true
+        else
+          auth.retry_auth?(response, client)
+        end
+      end
+
+      def read_token
+        @token ||= store.get(username, openshift_server) if store
+      end
+
+      def cannot_retry?
+        !@fetch_once && @no_interactive
+      end
+  end
+end

data/lib/rhc/auth/token_store.rb

@@ -0,0 +1,51 @@
+module RHC::Auth
+  class TokenStore
+    def initialize(dir)
+      @dir = dir
+    end
+
+    def get(login, server)
+      self[key(login,server)]
+    end
+
+    def put(login, server, token)
+      self[key(login,server)] = token
+    end
+
+    def clear
+      Dir[File.join(@dir, "token_*")].
+        each{ |f| File.delete(f) unless File.directory?(f) }.
+        present?
+    end
+
+    private
+      def path(key)
+        File.join(@dir, filename(key))
+      end
+
+      def filename(key)
+        "token_#{Base64.encode64(Digest::MD5.digest(key)).gsub(/[^\w\@]/,'')}"
+      end
+
+      def []=(key, value)
+        file = path(key)
+        FileUtils.mkdir_p File.dirname(file)
+        File.open(file, 'w'){ |f| f.write(value) }
+        File.chmod(0600, file)
+        value
+      end
+
+      def [](key)
+        s = IO.read(path(key)).presence
+        s = s.strip.gsub(/[\n\r\t]/,'') if s
+        s
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def key(login, server)
+        "#{login || ''}@#{server}"
+      end
+
+  end
+end

data/lib/rhc/auth.rb

@@ -1,3 +1,5 @@
 module RHC::Auth
-  autoload :Basic, 'rhc/auth/basic'
+  autoload :Basic,      'rhc/auth/basic'
+  autoload :Token,      'rhc/auth/token'
+  autoload :TokenStore, 'rhc/auth/token_store'
 end

data/lib/rhc/command_runner.rb

@@ -61,6 +61,7 @@ module RHC
           run_active_command
         rescue InvalidCommandError => e
           if provided_arguments.empty?
+            return RHC::Wizard.new.run unless RHC::Wizard.has_configuration?
             say RHC::HelpFormatter.new(self).render
           else
             RHC::Helpers.error "The command '#{program :name} #{provided_arguments.join(' ')}' is not recognized.\n"

data/lib/rhc/commands/account.rb

@@ -12,7 +12,7 @@ module RHC::Commands
     def run
       user = rest_client.user
 
-      say_table nil, get_properties(user, :login, :plan_id, :consumed_gears, :max_gears) + get_properties(user.capabilities, :gear_sizes), :delete => true
+      say_table nil, get_properties(user, :login, :plan_id, :consumed_gears, :max_gears) + get_properties(user.capabilities, :gear_sizes).unshift(['Server', openshift_server]), :delete => true
 
       if openshift_online_server?
       else
@@ -20,5 +20,51 @@ module RHC::Commands
 
       0
     end
+
+    summary "End the current session"
+    description <<-DESC
+      Logout ends your current session on the server and then removes
+      all of the local session files.  If you are using multiple 
+      servers and configurations this will remove all of your local
+      session files.
+
+      The --all option will terminate all authorizations on your
+      account. Any previously generated authorizations will be
+      deleted and external tools that integrate with your account
+      will no longer be able to log in.
+      DESC
+    option '--all', "Remove all authorizations on your account."
+    alias_action 'logout', :root_command => true
+    def logout
+      if options.all
+        rest_client.user # force authentication
+        say "Deleting all authorizations associated with your account ... "
+        begin
+          rest_client.delete_authorizations
+          success "done"
+        rescue RHC::Rest::AuthorizationsNotSupported
+          info "not supported"
+        end
+      elsif options.token
+        options.noprompt = true
+        say "Ending session on server ... "
+        begin
+          rest_client.delete_authorization(options.token)
+          success "deleted"
+        rescue RHC::Rest::AuthorizationsNotSupported
+          info "not supported"
+        rescue RHC::Rest::TokenExpiredOrInvalid
+          info "already closed"
+        rescue => e
+          debug_error(e)
+          warn e.message
+        end
+      end
+
+      0
+    ensure
+      token_store.clear
+      success "All local sessions removed."
+    end
   end
 end

data/lib/rhc/commands/alias.rb

@@ -14,8 +14,7 @@ module RHC::Commands
     option ["-n", "--namespace namespace"], "Namespace of your application", :context => :namespace_context, :required => true
     alias_action :"app add-alias", :root_command => true, :deprecated => true
     def add(app, app_alias)
-      rest_domain = rest_client.find_domain(options.namespace)
-      rest_app = rest_domain.find_application(app)
+      rest_app = rest_client.find_application(options.namespace, app)
       response = rest_app.add_alias(app_alias)
       results { say response.messages.first } if response.messages
       0
@@ -28,8 +27,7 @@ module RHC::Commands
     option ["-n", "--namespace namespace"], "Namespace of your application", :context => :namespace_context, :required => true
     alias_action :"app remove-alias", :root_command => true, :deprecated => true
     def remove(app, app_alias)
-      rest_domain = rest_client.find_domain(options.namespace)
-      rest_app = rest_domain.find_application(app)
+      rest_app = rest_client.find_application(options.namespace, app)
       response = rest_app.remove_alias(app_alias)
       results { say response.messages.first } if response.messages
       0

data/lib/rhc/commands/app.rb

@@ -59,7 +59,7 @@ module RHC::Commands
 
       raise ArgumentError, "You have named both your main application and your Jenkins application '#{name}'. In order to continue you'll need to specify a different name with --enable-jenkins or choose a different application name." if jenkins_app_name == name && enable_jenkins?
 
-      raise RHC::DomainNotFoundException.new("No domains found. Please create a domain with 'rhc domain create <namespace>' before creating applications.") if rest_client.domains.empty?
+      raise RHC::Rest::DomainNotFoundException.new("No domains found. Please create a domain with 'rhc domain create <namespace>' before creating applications.") if rest_client.domains.empty?
       rest_domain = rest_client.find_domain(options.namespace)
       rest_app = nil
 
@@ -177,9 +177,7 @@ module RHC::Commands
     argument :app, "The application you wish to delete", ["-a", "--app name"], :context => :app_context
     alias_action :destroy, :deprecated => true
     def delete(app)
-
-      rest_domain = rest_client.find_domain(options.namespace)
-      rest_app = rest_domain.find_application(app)
+      rest_app = rest_client.find_application(options.namespace, app)
 
       confirm_action "#{color("This is a non-reversible action! Your application code and data will be permanently deleted if you continue!", :yellow)}\n\nAre you sure you want to delete the application '#{app}'?"
 
@@ -260,18 +258,18 @@ module RHC::Commands
     syntax "<app> [--namespace namespace]"
     argument :app, "The name of the application you are getting information on", ["-a", "--app app"], :context => :app_context
     option ["-n", "--namespace namespace"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
-    option ["--state"], "Get the current state of the application's gears"
+    option ["--state"], "Get the current state of the cartridges in this application"
+    option ["--gears"], "Show the ID, state, and cartridges on each gear in this application"
     def show(app_name)
-      domain = rest_client.find_domain(options.namespace)
-      app = domain.find_application(app_name)
 
       if options.state
-        results do
-          app.gear_groups.each do |gg|
-            say "Gear group #{gg.cartridges.collect { |c| c['name'] }.join('+')} is #{gg.gears.first['state']}"
-          end
+        gear_groups_for_app(app_name).each do |gg|
+          say "Cartridge #{gg.cartridges.collect { |c| c['name'] }.join(', ')} is #{gear_group_state(gg.gears.map{ |g| g['state'] })}"
         end
+      elsif options.gears
+        say table(gear_groups_for_app(app_name).map{ |gg| gg.gears.map{ |g| [g['id'], g['state'], gg.cartridges.map{ |c| c['name'] }.join(", ")] } }.flatten(1))
       else
+        app = rest_client.find_application(options.namespace, app_name, :include => :cartridges)
         display_app(app, app.cartridges)
       end
 
@@ -288,16 +286,15 @@ module RHC::Commands
       raise ArgumentError, "No application specified" unless app_name.present?
       raise OptionParser::InvalidOption, "No system SSH available. Please use the --ssh option to specify the path to your SSH executable, or install SSH." unless options.ssh or has_ssh?
 
-      domain = rest_client.find_domain(options.namespace)
-      app = domain.find_application(app_name)
+      rest_app = rest_client.find_application(options.namespace, app_name)
 
-      say "Connecting to #{app.ssh_string.to_s} ..."
+      say "Connecting to #{rest_app.ssh_string.to_s} ..."
       if options.ssh
         debug "Using user specified SSH: #{options.ssh}"
-        Kernel.send(:system, "#{options.ssh} #{app.ssh_string.to_s}")
+        Kernel.send(:system, "#{options.ssh} #{rest_app.ssh_string.to_s}")
       else
         debug "Using system ssh"
-        Kernel.send(:system, "ssh #{app.ssh_string.to_s}")
+        Kernel.send(:system, "ssh #{rest_app.ssh_string.to_s}")
       end
     end
 
@@ -337,9 +334,17 @@ module RHC::Commands
         RHC::SSHWizard.new(rest_client, config, options).run
       end
 
+      def gear_groups_for_app(app_name)
+        rest_client.find_application_gear_groups(options.namespace, app_name)
+      end
+
+      def gear_group_state(states)
+        return states[0] if states.length == 1 || states.uniq.length == 1
+        "#{states.select{ |s| s == 'started' }.count}/#{states.length} started"
+      end
+
       def app_action(app, action, *args)
-        rest_domain = rest_client.find_domain(options.namespace)
-        rest_app = rest_domain.find_application(app)
+        rest_app = rest_client.find_application(options.namespace, app)
         result = rest_app.send action, *args
         result
       end

data/lib/rhc/commands/authorization.rb

@@ -0,0 +1,93 @@
+module RHC::Commands
+  class Authorization < Base
+
+    summary "Display the authorization tokens created under your account"
+    description <<-DESC
+      Shows the full list of authorization tokens on your account. You 
+      can add, edit, or delete authorizations with subcommands.
+
+      An authorization token grants access to the OpenShift REST API with
+      a set of privleges called 'scopes' for a limited time.  You can
+      add an optional note to each authorization token to assist you in
+      remembering what is available.
+      DESC
+    def run
+      rest_client.authorizations.each{ |auth| paragraph{ display_authorization(auth, options.token) } } or info "No authorizations"
+
+      0
+    end
+
+    option "--scopes SCOPES", "A comma delimited list of scopes (e.g. 'scope1,scope2')"
+    option "--note NOTE", "A description of this authorization (optional)"
+    option "--expires-in SECONDS", "The number of seconds before this authorization expires (optional)"
+    summary "Add an authorization to your account"
+    description <<-DESC
+      Add an authorization to your account. An authorization token grants
+      access to the OpenShift REST API with a set of privleges called 'scopes'
+      for a limited time.  You can add an optional note to each authorization
+      token to assist you in remembering what is available.
+
+      To view the list of scopes supported by this server, run this command
+      without any options.
+
+      You may pass multiple scopes to the --scopes option inside of double
+      quotes (--scopes \"scope1 scope2\") or by separating them with commas
+      (--scopes scope1,scope2).
+
+      The server will enforce a maximum and default expiration that may
+      differ for each scope. If you request an expiration longer than the
+      server maximum, you will be given the default value.
+      DESC
+    def add
+      unless options.scopes
+        say "When adding an authorization, you must specify which permissions clients will have."
+        scope_help
+        say "Run 'rhc authorization add --help' to see more options"
+        return 0
+      end
+
+      say "Adding authorization ... "
+      auth = rest_client.add_authorization(:scope => options.scopes, :note => options.note, :expires_in => options.expires_in)
+      success "done"
+      paragraph{ display_authorization(auth) }
+
+      0
+    end
+
+    summary "Delete one or more authorization tokens"
+    syntax "<token_or_id> [...<token_or_id>]"
+    description <<-DESC
+      Delete one or more of the authorization tokens associated with 
+      your account. After deletion, any clients using the token will
+      no longer have access to OpenShift and will need to reauthenticate.
+      DESC
+    argument :auth_token, "The token you wish to delete", ['--auth-token TOKEN'], :arg_type => :list
+    def delete(tokens)
+      raise ArgumentError, "You must specify one or more tokens to delete" if tokens.blank?
+      say "Deleting authorization ... "
+      tokens.each{ |token| rest_client.delete_authorization(token) }
+      success "done"
+      0
+    end
+
+    summary "Delete all authorization tokens from your account"
+    description <<-DESC
+      Delete all the authorization tokens associated with your account.
+      After deletion, any clients using those tokens will need to
+      reauthenticate.
+      DESC
+    def delete_all
+      say "Deleting all authorizations ... "
+      rest_client.delete_authorizations
+      success "done"
+      0
+    end
+
+    protected
+      def scope_help
+        descriptions = rest_client.authorization_scope_list
+        paragraph{ say table(descriptions, :header => ['Scope', 'Description']) }
+        paragraph{ say "You may pass multiple scopes to the --scopes option inside of double quotes (--scopes \"scope1 scope2\") or by separating them with commas (--scopes scope1,scope2)." }
+      end
+  end
+end

data/lib/rhc/commands/base.rb

@@ -28,8 +28,16 @@ class RHC::Commands::Base
     # the output (or failures) into exceptions and
     # formatted object output.  Most interactions 
     # should be through this call pattern.
-    def rest_client
-      @rest_client ||= client_from_options(:auth => RHC::Auth::Basic.new(options))
+    def rest_client(opts={})
+      @rest_client ||= begin
+          auth = RHC::Auth::Basic.new(options)
+          auth = RHC::Auth::Token.new(options, auth, token_store)
+          client_from_options(:auth => auth)
+        end
+    end
+
+    def token_store
+      @token_store ||= RHC::Auth::TokenStore.new(config.home_conf_path)
     end
 
     def help(*args)
@@ -79,7 +87,7 @@ class RHC::Commands::Base
       indent = o.scan(/^[ \t]*(?=\S)/).min.size || 0
       options[:description] =
         o.gsub(/^[ \t]{#{indent}}/, '').
-          gsub(/(\b)\s*\n(?!\s*\n)(\S)/m, '\1 \2').
+          gsub(/(\b|')\s*\n(?!\s*\n)(\S)/m, '\1 \2').
           gsub(/\n+\Z/, '').
           gsub(/\n{3,}/, "\n\n")
     end

data/lib/rhc/commands/cartridge.rb

@@ -46,8 +46,7 @@ module RHC::Commands
 
       say "Adding #{cart.name} to application '#{options.app}' ... "
 
-      rest_domain = rest_client.find_domain(options.namespace)
-      rest_app = rest_domain.find_application(options.app)
+      rest_app = rest_client.find_application(options.namespace, options.app, :include => :cartridges)
       rest_cartridge = rest_app.add_cartridge(cart.name)
 
       success "Success"
@@ -65,8 +64,7 @@ module RHC::Commands
     option ["-a", "--app app"], "Application you are adding the cartridge to", :context => :app_context, :required => true
     argument :cartridge, "The name of the cartridge", ["-c", "--cartridge cart_type"]
     def show(cartridge)
-      rest_domain = rest_client.find_domain(options.namespace)
-      rest_app = rest_domain.find_application(options.app)
+      rest_app = rest_client.find_application(options.namespace, options.app, :include => :cartridges)
       rest_cartridge = check_cartridges(cartridge, :from => rest_app.cartridges).first
 
       display_cart(rest_cartridge)
@@ -82,9 +80,7 @@ module RHC::Commands
     option ["--confirm"], "Pass to confirm removing the cartridge"
     alias_action :"app cartridge remove", :root_command => true, :deprecated => true
     def remove(cartridge)
-
-      rest_domain = rest_client.find_domain(options.namespace)
-      rest_app = rest_domain.find_application(options.app)
+      rest_app = rest_client.find_application(options.namespace, options.app, :include => :cartridges)
       rest_cartridge = check_cartridges(cartridge, :from => rest_app.cartridges).first
 
       confirm_action "Removing a cartridge is a destructive operation that may result in loss of data associated with the cartridge.\n\nAre you sure you wish to remove #{rest_cartridge.name} from '#{rest_app.name}'?"
@@ -136,8 +132,7 @@ module RHC::Commands
     option ["-a", "--app app"], "Application the cartridge belongs to", :context => :app_context, :required => true
     alias_action :"app cartridge status", :root_command => true, :deprecated => true
     def status(cartridge)
-      rest_domain = rest_client.find_domain(options.namespace)
-      rest_app = rest_domain.find_application(options.app)
+      rest_app = rest_client.find_application(options.namespace, options.app, :include => :cartridges)
       rest_cartridge = check_cartridges(cartridge, :from => rest_app.cartridges).first
       results { rest_cartridge.status.each{ |msg| say msg['message'] } }
       0
@@ -164,8 +159,7 @@ module RHC::Commands
     def scale(cartridge)
       raise RHC::MissingScalingValueException unless options.min || options.max
 
-      rest_domain = rest_client.find_domain(options.namespace)
-      rest_app = rest_domain.find_application(options.app)
+      rest_app = rest_client.find_application(options.namespace, options.app, :include => :cartridges)
       rest_cartridge = check_cartridges(cartridge, :from => rest_app.cartridges).first
 
       raise RHC::CartridgeNotScalableException unless rest_cartridge.scalable?
@@ -195,8 +189,7 @@ module RHC::Commands
     option ["-f", "--force"], "Force the action"
     def storage(cartridge)
       cartridges = Array(cartridge)
-      rest_domain = rest_client.find_domain(options.namespace)
-      rest_app = rest_domain.find_application(options.app)
+      rest_app = rest_client.find_application(options.namespace, options.app, :include => :cartridges)
 
       # Pull the desired action
       #
@@ -257,11 +250,10 @@ module RHC::Commands
       include RHC::CartridgeHelpers
 
       def cartridge_action(cartridge, action, &block)
-        rest_domain = rest_client.find_domain(options.namespace)
-        rest_app = rest_domain.find_application(options.app)
+        rest_app = rest_client.find_application(options.namespace, options.app, :include => :cartridges)
         rest_cartridge = check_cartridges(cartridge, :from => rest_app.cartridges).first
         result = rest_cartridge.send action
-        resp = [result, rest_cartridge, rest_app, rest_domain]
+        resp = [result, rest_cartridge, rest_app]
         yield resp if block_given?
         resp
       end