rhc 1.2.7 → 1.3.8

data/lib/rhc/cartridge_helpers.rb

@@ -6,12 +6,18 @@ module RHC
 
       if carts.length == 0
         valid_carts = rest_obj.cartridges.collect { |c| c.name if c.type == type }.compact
-        if valid_carts.length > 0
-          msg = "Valid cartridges are (#{valid_carts.join(', ')})."
-        else
-          msg = "No cartridges have been added to this app."
+
+        msg = if RHC::Rest::Application === rest_obj
+                "Cartridge '#{cartridge_name}' cannot be found in application '#{rest_obj.name}'."
+              else
+                "Cartridge '#{cartridge_name}' is not a valid cartridge name."
+              end
+
+        unless valid_carts.empty?
+          msg += "  Valid cartridges are (#{valid_carts.join(', ')})."
         end
-        raise RHC::CartridgeNotFoundException, "Invalid cartridge specified: '#{cartridge_name}'. #{msg}"
+
+        raise RHC::CartridgeNotFoundException, msg
       elsif carts.length > 1
         msg = "Multiple cartridge versions match your criteria. Please specify one."
         carts.each { |cart| msg += "\n  #{cart.name}" }

data/lib/rhc/cli.rb

@@ -21,10 +21,11 @@ module RHC
 
     def self.set_terminal
       $terminal.wrap_at = HighLine::SystemExtensions.terminal_size.first rescue 80 if $stdin.tty?
+      $terminal.page_at = :auto if $stdin.tty? and $stdout.tty?
       # FIXME: ANSI terminals are not default on windows but we may just be
       #        hitting a bug in highline if windows does support another method.
       #        This is a safe fix for now but needs more research.
-      HighLine::use_color = false if RHC::Helpers.windows?
+      HighLine::use_color = false if RHC::Helpers.windows? or not $stdout.tty?
     end
 
     def self.start(args)
@@ -35,9 +36,10 @@ module RHC
       program :description,    'Command line interface for OpenShift.'
       program :version,        RHC::VERSION::STRING
       program :help_formatter, RHC::HelpFormatter
+      program :int_message,    " Interrupted\n"
 
       RHC::Commands.load.to_commander
-      exit(run! || 0)
+      run! || 0
     end
   end
 end

data/lib/rhc/command_runner.rb

@@ -6,8 +6,16 @@ module RHC
       commands.keys.find_all { |name| name if /^#{name}\b/.match arg_string }
     end
 
+    if Commander::VERSION == '4.0.3'
+      #:nocov:
+      def program(*args)
+        Array(super).first
+      end
+      #:nocov:
+    end
+
     def options_parse_trace
-      if @args.include? "--trace"
+      if @args.include?("--trace")
         @args.delete "--trace"
         return true
       end
@@ -15,7 +23,7 @@ module RHC
     end
 
     def options_parse_version
-      if @args.include? "--version" or @args.include? "-v"
+      if @args.include? "--version"
         say version
         exit 0
       end
@@ -25,16 +33,15 @@ module RHC
     def run!
       trace = false
       require_program :version, :description
+      #trap('INT') { abort program(:int_message) } if program(:int_message)
+      #trap('INT') { program(:int_block).call } if program(:int_block)
 
-      trap('INT') { abort program(:int_message) } if program(:int_message)
-      trap('INT') { program(:int_block).call } if program(:int_block)
-
-      global_option('-h', '--help', 'Display help documentation') do
+      global_option('-h', '--help', 'Help on any command', :hide => true) do
         args = @args - %w[-h --help]
         command(:help).run(*args)
         return
       end
-      global_option('-v', '--version', 'Display version information') { say version; return }
+      global_option('--version', 'Display version information', :hide => true) { say version; return }
 
       # remove these because we monkey patch Commands to process all options
       # at once, avoiding conflicts between the global and command options
@@ -60,15 +67,24 @@ module RHC
             say "See '#{program :name} help' for a list of valid commands."
           end
           1
+        rescue \
+          OptionParser::InvalidOption => e
+          RHC::Helpers.error e.message
+          1
         rescue \
           ArgumentError,
-          OptionParser::InvalidOption,
-          OptionParser::InvalidArgument,
-          OptionParser::MissingArgument => e
+          OptionParser::ParseError => e
 
           help_bindings = CommandHelpBindings.new(active_command, commands, self)
           usage = RHC::HelpFormatter.new(self).render_command_syntax(help_bindings)
-          RHC::Helpers.error e.message
+          message = case e
+          when OptionParser::AmbiguousOption
+            "The option #{e.args.join(' ')} is ambiguous. You will need to specify the entire option."
+          else
+            e.message
+          end
+
+          RHC::Helpers.error message
           say "#{usage}"
           1
         rescue RHC::Exception, RHC::Rest::Exception => e
@@ -92,8 +108,15 @@ module RHC
     end
 
     def create_default_commands
+      command 'help options' do |c|
+#        c.syntax = ''
+        c.description = "Display all global options and information about configuration"
+        c.when_called do |args, options|
+          say help_formatter.render_options self
+        end
+      end
       command :help do |c|
-        c.syntax = 'rhc help <command>'
+        c.syntax = '<command>'
         c.description = 'Display global or <command> help documentation.'
         c.when_called do |args, options|
           cmd = (1..args.length).reverse_each.map{ |n| args[0,n].join(' ') }.find{ |cmd| command_exists?(cmd) }
@@ -113,22 +136,4 @@ module RHC
       end
     end
   end
-
-  class CommandHelpBindings
-    def initialize(command, instance_commands, runner)
-      @command = command
-      @actions = instance_commands.collect do |command_name, command_class|
-        next if command_class.summary.nil?
-        m = /^#{command.name} ([^ ]+)/.match(command_name)
-        # if we have a match and it is not an alias then we can use it
-        m and command_name == command_class.name ? {:name => m[1], :summary => command_class.summary || ""} : nil
-      end
-      @actions.compact!
-      @global_options = runner.options
-      @runner = runner
-    end
-    def program(*args)
-      @runner.program *args
-    end
-  end
 end

data/lib/rhc/commands.rb

@@ -1,5 +1,5 @@
 require 'commander'
-require 'rhc/helpers'
+require 'commander/command'
 
 ## monkey patch option parsing to also parse global options all at once
 #  to avoid conflicts and side effects of similar short switches
@@ -11,14 +11,12 @@ module Commander
     end
 
     def parse_options_and_call_procs *args
-      return args if args.empty?
-      opts = OptionParser.new
       runner = Commander::Runner.instance
+      opts = OptionParser.new
+
       # add global options
       runner.options.each do |option|
-        opts.on *option[:args],
-                &runner.global_option_proc(option[:switches], &option[:proc])
-
+        opts.on(*option[:args], &runner.global_option_proc(option[:switches], &option[:proc]))
       end
 
       # add command options
@@ -27,13 +25,76 @@ module Commander
         opts
       end
 
-      opts.parse! args
+      remaining = opts.parse! args
+
+      _, config_path = proxy_options.find{ |arg| arg[0] == :config }
+      clean, _ = proxy_options.find{ |arg| arg[0] == :clean }
+
+      begin
+        @config = RHC::Config.new
+        @config.use_config(config_path) if config_path
+
+        unless clean
+          @config.to_options.each_pair do |key, value|
+            next if proxy_options.detect{ |arr| arr[0] == key }
+            if sw = opts.send(:search, :long, key.to_s.gsub(/_/, '-'))
+              _, cb, val = sw.send(:conv_arg, nil, value) {|*exc| raise(*exc) }
+              cb.call(val) if cb
+            end
+          end
+        end
+      rescue ArgumentError => e
+        n = OptionParser::InvalidOption.new(e.message)
+        n.reason = "The configuration file #{@config.path} contains an invalid setting"
+        n.set_backtrace(e.backtrace)
+        raise n
+      rescue OptionParser::ParseError => e
+        e.reason = "The configuration file #{@config.path} contains an invalid setting"
+        raise
+      end
+      remaining
+    end
+  end
+end
+
+#
+# Allow Command::Options to lazily evaluate procs and lambdas
+#
+module Commander
+  class Command
+    class Options
+      def initialize(init=nil)
+        @table = {}
+        default(init) if init
+      end
+      def method_missing meth, *args, &block
+        meth.to_s =~ /=$/ ? self[meth.to_s.chop] = args.first : self[meth]
+      end
+      def []=(meth, value)
+        @table[meth.to_sym] = value
+      end
+      def [](meth)
+        value = @table[meth.to_sym]
+        value = value.call if value.is_a? Proc
+        value
+      end
+      def default defaults = {}
+        @table = @table.reverse_merge!(__to_hash__(defaults))
+      end
+      def __replace__(options)
+        @table = __to_hash__(options).dup
+      end
+      def __to_hash__(obj)
+        Options === obj ? obj.__hash__ : obj
+      end
     end
   end
 end
 
 module RHC
   module Commands
+    autoload :Base, 'rhc/commands/base'
+
     def self.load
       Dir[File.join(File.dirname(__FILE__), "commands", "*.rb")].each do |file|
         require file
@@ -47,13 +108,6 @@ module RHC
       global_options << [args, block]
     end
 
-    def self.global_config_setup(options)
-      RHC::Config.set_opts_config(options.config) if options.config
-      RHC::Config.password = options.password if options.password
-      RHC::Config.opts_login = options.rhlogin if options.rhlogin
-      RHC::Config
-    end
-
     def self.deprecated?
       command_name = Commander::Runner.instance.command_name_from_args
       command = Commander::Runner.instance.active_command
@@ -125,17 +179,17 @@ module RHC
           end
 
           c.when_called do |args, options|
-            config = global_config_setup(options)
             deprecated?
 
+            config = c.instance_variable_get(:@config)
+
             cmd = opts[:class].new
             cmd.options = options
             cmd.config = config
 
-            filled_args = cmd.validate_args_and_options(args_metadata, options_metadata, args)
-
+            args = fill_arguments(cmd, options, args_metadata, options_metadata, args)
             needs_configuration!(cmd, options, config)
-            cmd.send(opts[:method], *filled_args)
+            execute(cmd, opts[:method], args)
           end
         end
       end
@@ -143,6 +197,61 @@ module RHC
     end
 
     protected
+      def self.execute(cmd, method, args)
+        cmd.send(method, *args)
+      end
+
+      def self.fill_arguments(cmd, options, args_metadata, options_metadata, args)
+        # process options
+        options_metadata.each do |option_meta|
+          arg = option_meta[:arg]
+
+          # Check to see if we've provided a value for an option tagged as deprecated
+          if (!(val = options.__hash__[arg]).nil? && dep_info = option_meta[:deprecated])
+            # Get the arg for the correct option and what the value should be
+            (correct_arg, default) = dep_info.values_at(:key, :value)
+            # Set the default value for the correct option to the passed value
+            ## Note: If this isn't triggered, then the original default will be honored
+            ## If the user specifies any value for the correct option, it will be used
+            options.default correct_arg => default
+            # Alert the users if they're using a deprecated option
+            (correct, incorrect) = [options_metadata.find{|x| x[:arg] == correct_arg },option_meta].flatten.map{|x| x[:switches].join(", ") }
+            RHC::Helpers.deprecated_option(incorrect, correct)
+          end
+
+          if context_helper = option_meta[:context_helper]
+            options[arg] = lambda{ cmd.send(context_helper) } if options.__hash__[arg].nil?
+          end
+          raise ArgumentError.new("Missing required option '#{arg}'.") if option_meta[:required] && options[arg].nil?
+        end
+        # process args
+        arg_slots = [].fill(nil, 0, args_metadata.length)
+        fill_args = args.reverse
+        args_metadata.each_with_index do |arg_meta, i|
+          # check options
+          option = arg_meta[:option_symbol]
+          context_helper = arg_meta[:context_helper]
+
+          value = options.__hash__[option] if option
+          value = fill_args.pop if value.nil?
+          value = cmd.send(context_helper) if value.nil? and context_helper
+
+          if arg_meta[:arg_type] == :list
+            fill_args.push(value) unless value.nil?
+            value = fill_args.reverse
+            fill_args = []
+          elsif value.nil?
+            raise ArgumentError.new("Missing required argument '#{arg_meta[:name]}'.") if fill_args.empty?
+          end
+          arg_slots[i] = value
+          options.__hash__[option] = value if option
+        end
+
+        raise ArgumentError.new("Too many arguments passed in: #{fill_args.reverse.join(" ")}") unless fill_args.empty?
+
+        arg_slots
+      end
+
       def self.commands
         @commands ||= {}
       end

data/lib/rhc/commands/account.rb

@@ -0,0 +1,24 @@
+module RHC::Commands
+  class Account < Base
+    suppress_wizard
+
+    summary "Display details about your OpenShift account"
+    description <<-DESC
+      Shows who you are logged in to the server as and the capabilities
+      available to you on this server.
+
+      To access more details about your account please visit the website.
+      DESC
+    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
+
+      if openshift_online_server?
+      else
+      end
+
+      0
+    end
+  end
+end

data/lib/rhc/commands/alias.rb

@@ -1,6 +1,6 @@
 require 'rhc/commands/base'
 require 'rhc/config'
-require 'rhc-common'
+
 module RHC::Commands
   class Alias < Base
     summary "Add or remove a custom domain name for the application"

data/lib/rhc/commands/app.rb

@@ -1,6 +1,6 @@
 require 'rhc/commands/base'
 require 'resolv'
-require 'rhc/git_helper'
+require 'rhc/git_helpers'
 require 'rhc/cartridge_helpers'
 
 module RHC::Commands
@@ -10,13 +10,39 @@ module RHC::Commands
     syntax "<action>"
     default_action :help
 
-    summary "Create an application and adds it to a domain"
-    description "Create an application in your domain. You can see a list of all valid cartridge types by running 'rhc cartridge list'."
+    summary "Create an application"
+    description <<-DESC
+      Create an application. Every OpenShift application must have one 
+      web cartridge which serves web requests, and can have a number of
+      other cartridges which provide capabilities like databases, 
+      scheduled jobs, or continuous integration.
+
+      You can see a list of all valid cartridge types by running 
+      'rhc cartridge list'.
+
+      When your application is created, a domain name that is a combination
+      of the name of your app and the namespace of your domain will be 
+      registered in DNS.  A copy of the code for your application
+      will be checked out locally into a folder with the same name as 
+      your application.  Note that different types of applications may
+      require different structures - check the README provided with the
+      cartridge if you have questions.
+
+      OpenShift runs the components of your application on small virtual 
+      servers called "gears".  Each account or plan is limited to a number
+      of gears which you can use across multiple applications.  Some 
+      accounts or plans provide access to gears with more memory or more
+      CPU.  Run 'rhc account' to see the number and sizes of gears available
+      to you.  When creating an application the --gear-size parameter
+      may be specified to change the gears used.
+
+      DESC
     syntax "<name> <cartridge> [-n namespace]"
-    option ["-n", "--namespace namespace"], "Namespace for the application", :context => :namespace_context, :required => true
+    option ["-n", "--namespace namespace"], "Namespace for the application", :context => :namespace_context
     option ["-g", "--gear-size size"], "Gear size controls how much memory and CPU your cartridges can use."
     option ["-s", "--scaling"], "Enable scaling for the web cartridge."
     option ["-r", "--repo dir"], "Path to the Git repository (defaults to ./$app_name)"
+    option ["--from-code URL"], "URL to a Git repository that will become the initial contents of the application"
     option ["--[no-]git"], "Skip creating the local Git repository."
     option ["--nogit"], "DEPRECATED: Skip creating the local Git repository.", :deprecated => {:key => :git, :value => false}
     option ["--[no-]dns"], "Skip waiting for the application DNS name to resolve. Must be used in combination with --no-git"
@@ -25,151 +51,142 @@ module RHC::Commands
     argument :cartridges, "The web framework this application should use", ["-t", "--type cartridge"], :arg_type => :list
     #argument :additional_cartridges, "A list of other cartridges such as databases you wish to add. Cartridges can also be added later using 'rhc cartridge add'", [], :arg_type => :list
     def create(name, cartridges)
-      cartridge = check_cartridges(cartridges).first
+      cartridges = check_cartridges(cartridges)
 
       options.default \
         :dns => true,
         :git => true
 
-      header "Creating application '#{name}'"
+      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?
+      rest_domain = rest_client.find_domain(options.namespace)
+      rest_app = nil
+
       paragraph do
-        table({"Namespace:" => options.namespace,
-               "Cartridge:" => cartridge,
-               "Gear Size:" => options.gear_size || "default",
-               "Scaling:" => options.scaling ? "yes" : "no",
-              }
+        header "Application Options"
+        table([["Namespace:", options.namespace],
+               ["Cartridges:", cartridges.map(&:name).join(', ')],
+              (["Source Code:", options.from_code] if options.from_code),
+               ["Gear Size:", options.gear_size || "default"],
+               ["Scaling:", options.scaling ? "yes" : "no"],
+              ].compact
              ).each { |s| say "  #{s}" }
       end
 
-      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?
+      messages = []
 
-      rest_app, rest_domain = nil
-      raise RHC::DomainNotFoundException.new("No domains found. Please create a domain with 'rhc domain create <namespace>' before creating applications.") if rest_client.domains.empty?
+      paragraph do
+        say "Creating application '#{name}' ... "
 
-      rest_domain = rest_client.find_domain(options.namespace)
 
-      # check to make sure the right options are set for enabling jenkins
-      jenkins_rest_app = check_jenkins(name, rest_domain) if enable_jenkins?
-
-      # create the main app
-      rest_app = create_app(name, cartridge, rest_domain,
-                            options.gear_size, options.scaling)
-
-      # create a jenkins app if not available
-      # don't error out if there are issues, setup warnings instead
-      begin
-        jenkins_rest_app = setup_jenkins_app(rest_domain) if enable_jenkins? and jenkins_rest_app.nil?
-      rescue Exception => e
-        add_issue("Jenkins failed to install - #{e}",
-                  "Installing jenkins and jenkins-client",
-                  "rhc app create jenkins",
-                  "rhc cartridge add jenkins-client -a #{rest_app.name}")
+        # create the main app
+        rest_app = create_app(name, cartridges.map(&:name), rest_domain,
+                              options.gear_size, options.scaling, options.from_code)
+
+        messages.concat(rest_app.messages)
+
+        success "done"
       end
 
-      if jenkins_rest_app
-        success, attempts, exit_code, exit_message = false, 1, 157, nil
-        while (!success && exit_code == 157 && attempts < MAX_RETRIES)
-          begin
-            setup_jenkins_client(rest_app)
-            success = true
-          rescue RHC::Rest::ServerErrorException => e
-            if (e.code == 157)
-              # error downloading Jenkins /jnlpJars/jenkins-cli.jar
-              attempts += 1
-              debug "Jenkins server could not be contacted, sleep and then retry: attempt #{attempts}\n    #{e.message}"
-              Kernel.sleep(10)
+      build_app_exists = rest_app.building_app
+
+      if enable_jenkins?
+        unless build_app_exists
+          paragraph do
+            say "Setting up a Jenkins application ... "
+
+            begin
+              build_app_exists = add_jenkins_app(rest_domain)
+
+              success "done"
+              messages.concat(build_app_exists.messages)
+
+            rescue Exception => e
+              warn "not complete"
+              add_issue("Jenkins failed to install - #{e}",
+                        "Installing jenkins and jenkins-client",
+                        "rhc app create jenkins",
+                        "rhc cartridge add jenkins-client -a #{rest_app.name}")
             end
-            exit_code = e.code
-            exit_message = e.message
-          rescue Exception => e
-            # timeout and other exceptions
-            exit_code = 1
-            exit_message = e.message
           end
         end
-        add_issue("Jenkins client failed to install - #{exit_message}",
-                  "Install the jenkins client",
-                  "rhc cartridge add jenkins-client -a #{rest_app.name}") if !success
+
+        paragraph do
+          add_jenkins_client_to(rest_app, messages)
+        end if build_app_exists
       end
 
       if options.dns
-        say "Your application's domain name is being propagated worldwide (this might take a minute)..."
-        unless dns_propagated? rest_app.host
-          add_issue("We were unable to lookup your hostname (#{rest_app.host}) in a reasonable amount of time and can not clone your application.",
-                    "Clone your git repo",
-                    "rhc app git-clone #{rest_app.name}")
-
-          output_issues(rest_app)
-          return 0
+        paragraph do
+          say "Waiting for your DNS name to be available ... "
+          if dns_propagated? rest_app.host
+            success "done"
+          else
+            warn "failure"
+            add_issue("We were unable to lookup your hostname (#{rest_app.host}) in a reasonable amount of time and can not clone your application.",
+                      "Clone your git repo",
+                      "rhc git-clone #{rest_app.name}")
+
+            output_issues(rest_app)
+            return 0
+          end
         end
 
         if options.git
-          begin
-            run_git_clone(rest_app)
-          rescue RHC::GitException => e
-            warn "#{e}"
-            unless RHC::Helpers.windows? and windows_nslookup_bug?(rest_app)
-              add_issue("We were unable to clone your application's git repo - #{e}",
-                        "Clone your git repo",
-                        "rhc app git-clone #{rest_app.name}")
+          paragraph do
+            debug "Checking SSH keys through the wizard"
+            check_sshkeys! unless options.noprompt
+
+            say "Downloading the application Git repository ..."
+            paragraph do
+              begin
+                git_clone_application(rest_app)
+              rescue RHC::GitException => e
+                warn "#{e}"
+                unless RHC::Helpers.windows? and windows_nslookup_bug?(rest_app)
+                  add_issue("We were unable to clone your application's git repo - #{e}",
+                            "Clone your git repo",
+                            "rhc git-clone #{rest_app.name}")
+                end
+              end
             end
           end
         end
       end
 
-      display_app(rest_app, rest_app.cartridges, rest_app.scalable_carts.first)
+      display_app(rest_app, rest_app.cartridges)
 
       if issues?
         output_issues(rest_app)
       else
-        results {
-          rest_app.messages.each { |msg| say msg }
-          jenkins_rest_app.messages.each { |msg| say msg } if enable_jenkins? and jenkins_rest_app
-        }
+        results{ messages.each { |msg| success msg } }.blank? and "Application created"
       end
 
       0
     end
 
-    summary "Clone and configure an application's repository locally"
-    description "This is a convenience wrapper for 'git clone' with the added",
-                "benefit of adding configuration data such as the application's",
-                "UUID to the local repository.  It also automatically",
-                "figures out the git url from the application name so you don't",
-                "have to look it up."
-    syntax "<app> [--namespace namespace]"
-    option ["-n", "--namespace namespace"], "Namespace to add your application to", :context => :namespace_context, :required => true
-    argument :app, "The application you wish to clone", ["-a", "--app name"]
-    # TODO: Implement default values for arguments once ffranz has added context arguments
-    # argument :directory, "The name of a new directory to clone into", [], :default => nil
-    def git_clone(app)
-      rest_domain = rest_client.find_domain(options.namespace)
-      rest_app = rest_domain.find_application(app)
-      run_git_clone(rest_app)
-      0
-    end
 
     summary "Delete an application from the server"
     description "Deletes your application and all of its data from the server.",
                 "Use with caution as this operation is permanent."
     syntax "<app> [--namespace namespace]"
-    option ["-n", "--namespace namespace"], "Namespace to add your application to", :context => :namespace_context, :required => true
+    option ["-n", "--namespace namespace"], "Namespace your application belongs to", :context => :namespace_context, :required => true
     option ["-b", "--bypass"], "DEPRECATED Please use '--confirm'", :deprecated => {:key => :confirm, :value => true}
-    option ["--confirm"], "Deletes the application without prompting the user"
-    argument :app, "The application you wish to delete", ["-a", "--app name"]
+    option ["--confirm"], "Pass to confirm deleting the application"
+    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)
-      do_delete = true
 
-      do_delete = agree "Are you sure you wish to delete the '#{rest_app.name}' application? (yes/no)" unless options.confirm
+      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}'?"
+
+      say "Deleting application '#{rest_app.name}' ... "
+      rest_app.destroy
+      success "deleted"
 
-      if do_delete
-        paragraph { say "Deleting application '#{rest_app.name}'" }
-        rest_app.destroy
-        results { say "Application '#{rest_app.name}' successfully deleted" }
-      end
       0
     end
 
@@ -231,7 +248,7 @@ module RHC::Commands
     summary "Clean out the application's logs and tmp directories and tidy up the git repo on the server"
     syntax "<app> [--namespace namespace] [--app app]"
     argument :app, "The name of the application you are tidying", ["-a", "--app app"], :context => :app_context
-    option ["-n", "--namespace namespace"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
+    option ["-n", "--namespace namespace"], "Namespace of the application belongs to", :context => :namespace_context, :required => true
     def tidy(app)
       app_action app, :tidy
 
@@ -240,29 +257,31 @@ module RHC::Commands
     end
 
     summary "Show information about an application"
-    syntax "<app> [--namespace namespace] [--app app]"
+    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"
-    def show(app)
-      rest_domain = rest_client.find_domain(options.namespace)
-      rest_app = rest_domain.find_application(app)
-      unless options.state
-        display_app(rest_app,rest_app.cartridges,rest_app.scalable_carts.first)
-      else
+    def show(app_name)
+      domain = rest_client.find_domain(options.namespace)
+      app = domain.find_application(app_name)
+
+      if options.state
         results do
-          rest_app.gear_groups.each do |gg|
-            say "Geargroup #{gg.cartridges.collect { |c| c['name'] }.join('+')} is #{gg.gears.first['state']}"
+          app.gear_groups.each do |gg|
+            say "Gear group #{gg.cartridges.collect { |c| c['name'] }.join('+')} is #{gg.gears.first['state']}"
           end
         end
+      else
+        display_app(app, app.cartridges)
       end
+
       0
     end
 
-    summary "Show status of an application's gears"
+    summary "DEPRECATED use 'show <app> --state' instead"
     syntax "<app> [--namespace namespace] [--app app]"
     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 ["-n", "--namespace namespace"], "Namespace of the application belongs to", :context => :namespace_context, :required => true
     deprecated "rhc app show --state"
     def status(app)
       # TODO: add a way to deprecate this and alias to show --apache
@@ -274,33 +293,46 @@ module RHC::Commands
       include RHC::GitHelpers
       include RHC::CartridgeHelpers
 
+      def check_sshkeys!
+        RHC::SSHWizard.new(rest_client, config, options).run
+      end
+
       def standalone_cartridges
-        @standalone_cartridges ||= rest_client.cartridges.select{ |c| c.type == 'standalone' }
+        @standalone_cartridges ||= all_cartridges.select{ |c| c.type == 'standalone' }
+      end
+      def all_cartridges
+        @all_cartridges = rest_client.cartridges
       end
 
       def check_cartridges(cartridge_names)
         cartridge_names = Array(cartridge_names).map{ |s| s.strip if s && s.length > 0 }.compact
 
-        unless cartridge_name = cartridge_names.first
-          section(:bottom => 1){ list_cartridges }
-          raise ArgumentError.new "Every application needs a web cartridge to handle incoming web requests. Please provide the short name of one of the carts listed above."
-        end
-
-        unless standalone_cartridges.find{ |c| c.name == cartridge_name }
-          matching_cartridges = standalone_cartridges.select{ |c| c.name.include?(cartridge_name) }
-          if matching_cartridges.length == 1
-            cartridge_names[0] = use_cart(matching_cartridges.first, cartridge_name)
-          elsif matching_cartridges.present?
-            paragraph { list_cartridges(matching_cartridges) }
-            raise RHC::MultipleCartridgesException.new("There are multiple web cartridges named '#{cartridge_name}'.  Please provide the short name of your desired cart.")
+        cartridge_names.map do |name|
+          all_cartridges.find{ |c| c.name == name } ||
+            begin
+              matching_cartridges = all_cartridges.select{ |c| c.name.include?(name) }
+              unless matching_cartridges.length == 1
+                if matching_cartridges.present?
+                  paragraph { list_cartridges(matching_cartridges) }
+                  raise RHC::MultipleCartridgesException, "There are multiple web cartridges named '#{name}'. Please provide the short name of your desired cart." if matching_cartridges.present?
+                else
+                  paragraph { list_cartridges(all_cartridges) }
+                  raise RHC::CartridgeNotFoundException, "There are no cartridges that match '#{name}'."
+                end
+              end
+              use_cart(matching_cartridges.first, name)
+            end
+        end.tap do |carts|
+          if carts.none?(&:only_in_new?)
+            section(:bottom => 1){ list_cartridges }
+            raise RHC::CartridgeNotFoundException, "Every application needs a web cartridge to handle incoming web requests. Please provide the short name of one of the carts listed above."         
           end
         end
-        cartridge_names.first(1)
       end
 
       def use_cart(cart, for_cartridge_name)
-        info "Using #{cart.name}#{cart.display_name ? " (#{cart.display_name})" : ''} instead of '#{for_cartridge_name}'"
-        cart.name
+        info "Using #{cart.name}#{cart.display_name ? " (#{cart.display_name})" : ''} for '#{for_cartridge_name}'"
+        cart
       end
 
       def list_cartridges(cartridges=standalone_cartridges)
@@ -317,14 +349,14 @@ module RHC::Commands
         result
       end
 
-      def create_app(name, cartridge, rest_domain, gear_size=nil, scale=nil)
-        app_options = {:cartridge => cartridge}
+      def create_app(name, cartridges, rest_domain, gear_size=nil, scale=nil, from_code=nil)
+        app_options = {:cartridges => Array(cartridges)}
         app_options[:gear_profile] = gear_size if gear_size
         app_options[:scale] = scale if scale
+        app_options[:initial_git_url] = from_code if from_code
         app_options[:debug] = true if @debug
-
         debug "Creating application '#{name}' with these options - #{app_options.inspect}"
-        rest_app = rest_domain.add_application name, app_options
+        rest_app = rest_domain.add_application(name, app_options)
         debug "'#{rest_app.name}' created"
 
         rest_app
@@ -336,6 +368,48 @@ module RHC::Commands
         raise
       end
 
+      def add_jenkins_app(rest_domain)
+        create_app(jenkins_app_name, "jenkins-1.4", rest_domain)
+      end
+
+      def add_jenkins_cartridge(rest_app)
+        rest_app.add_cartridge("jenkins-client-1.4")
+      end
+
+      def add_jenkins_client_to(rest_app, messages)
+        say "Setting up Jenkins build ... "
+        successful, attempts, exit_code, exit_message = false, 1, 157, nil
+        while (!successful && exit_code == 157 && attempts < MAX_RETRIES)
+          begin
+            cartridge = add_jenkins_cartridge(rest_app)
+            successful = true
+
+            success "done"
+            messages.concat(cartridge.messages)
+
+          rescue RHC::Rest::ServerErrorException => e
+            if (e.code == 157)
+              # error downloading Jenkins /jnlpJars/jenkins-cli.jar
+              attempts += 1
+              debug "Jenkins server could not be contacted, sleep and then retry: attempt #{attempts}\n    #{e.message}"
+              Kernel.sleep(10)
+            end
+            exit_code = e.code
+            exit_message = e.message
+          rescue Exception => e
+            # timeout and other exceptions
+            exit_code = 1
+            exit_message = e.message
+          end
+        end
+        unless successful
+          warn "not complete"
+          add_issue("Jenkins client failed to install - #{exit_message}",
+                    "Install the jenkins client",
+                    "rhc cartridge add jenkins-client -a #{rest_app.name}")
+        end
+      end
+
       def dns_propagated?(host, sleep_time=2)
         #
         # Confirm that the host exists in DNS
@@ -362,88 +436,15 @@ module RHC::Commands
         found
       end
 
-      def check_sshkeys!
-        wizard = RHC::SSHWizard.new(rest_client)
-        wizard.run
-      end
-
-      def run_git_clone(rest_app)
-        debug "Pulling new repo down"
-
-        check_sshkeys! unless options.noprompt
-
-        repo_dir = options.repo || rest_app.name
-        git_clone_repo rest_app.git_url, repo_dir
-
-        configure_git rest_app
-
-        true
-      end
-
-      def configure_git(rest_app)
-        debug "Configuring git repo"
-
-        repo_dir = options.repo || rest_app.name
-        Dir.chdir(repo_dir) do |dir|
-          git_config_set "rhc.app-uuid", rest_app.uuid
-        end
-      end
-
       def enable_jenkins?
         # legacy issue, commander 4.0.x will place the option in the hash with nil value (BZ878407)
         options.__hash__.has_key?(:enable_jenkins)
       end
 
       def jenkins_app_name
-        return "jenkins" if options.enable_jenkins == true || options.enable_jenkins == "true" || (enable_jenkins? && options.enable_jenkins.nil?)
-        return options.enable_jenkins if options.enable_jenkins.is_a?(String)
-        nil
-      end
-
-      def check_jenkins(app_name, rest_domain)
-        debug "Checking if jenkins arguments are valid"
-        raise ArgumentError, "The --no-dns option can't be used in conjunction with --enable-jenkins when creating an application.  Either remove the --no-dns option or first install your application with --no-dns and then use 'rhc cartridge add' to embed the Jenkins client." unless options.dns
-
-
-        begin
-          jenkins_rest_app = rest_domain.find_application(:framework => "jenkins-1.4")
-        rescue RHC::ApplicationNotFoundException
-          debug "No Jenkins apps found during check"
-
-          # app name and jenkins app name are the same
-          raise ArgumentError, "You have named both your main application and your Jenkins application '#{app_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 == app_name
-
-          # jenkins app name and existing app are the same
-          begin
-            rest_app = rest_domain.find_application(:name => jenkins_app_name)
-            raise ArgumentError, "You have named your Jenkins application the same as an existing application '#{app_name}'. In order to continue you'll need to specify a different name with --enable-jenkins or delete the current application using 'rhc app delete #{app_name}'"
-          rescue RHC::ApplicationNotFoundException
-          end
-
-          debug "Jenkins arguments valid"
-          return nil
-        end
-
-        say "Found existing Jenkins application: #{jenkins_rest_app.name}"
-        say "Ignoring user specified Jenkins app name : #{options.enable_jenkins}" if jenkins_rest_app.name != options.enable_jenkins and options.enable_jenkins.is_a?(String)
-
-        debug "Jenkins arguments valid"
-        jenkins_rest_app
-      end
-
-      def setup_jenkins_app(rest_domain)
-        debug "Creating a new jenkins application"
-        rest_app = create_app(jenkins_app_name, "jenkins-1.4", rest_domain)
-
-        say "Jenkins domain name is being propagated worldwide (this might take a minute)..."
-        # If we can't get the dns we can't install the client so return nil
-        dns_propagated?(rest_app.host) ? rest_app : nil
-
-      end
-
-      def setup_jenkins_client(rest_app)
-        rest_app.add_cartridge("jenkins-client-1.4", 300)
+        if options.enable_jenkins.is_a? String
+          options.enable_jenkins
+        end || "jenkins"
       end
 
       def run_nslookup(host)
@@ -477,7 +478,7 @@ We recommend you wait a few minutes then clone your git repository manually.
 WINSOCKISSUE
           add_issue(issue,
                     "Clone your git repo",
-                    "rhc app git-clone #{rest_app.name}")
+                    "rhc git-clone #{rest_app.name}")
 
           return true
         end