rhc 0.98.16 → 1.0.4

data/lib/rhc/commands/base.rb

@@ -10,13 +10,12 @@ require 'rhc/context_helper'
 class RHC::Commands::Base
 
   attr_writer :options, :config
+  attr_reader :messages
 
   def initialize(options=Commander::Command::Options.new,
                  config=nil)
     @options, @config = options, config
-
-    # apply timeout here even though it isn't quite a global
-    $rest_timeout = @options.timeout ? @options.timeout.to_i : nil
+    @messages = []
   end
 
   def validate_args_and_options(args_metadata, options_metadata, args)
@@ -24,7 +23,21 @@ class RHC::Commands::Base
     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(", ") }
+        deprecated_option(incorrect, correct)
+      end
+
       context_helper = option_meta[:context_helper]
+
       @options.__hash__[arg] = self.send(context_helper) if @options.__hash__[arg].nil? and context_helper
       raise ArgumentError.new("Missing required option '#{arg}'.") if option_meta[:required] and @options.__hash__[arg].nil?
     end
@@ -34,7 +47,7 @@ class RHC::Commands::Base
     fill_args = args.reverse
     args_metadata.each_with_index do |arg_meta, i|
       # check options
-      value = @options.__hash__[arg_meta[:name]]
+      value = @options.__hash__[arg_meta[:option_symbol]] unless arg_meta[:option_symbol].nil?
       if value
         arg_slots[i] = value
       elsif arg_meta[:arg_type] == :list
@@ -87,12 +100,20 @@ class RHC::Commands::Base
           username = ask "To connect to #{openshift_server} enter your OpenShift login (email or Red Hat login id): "
           config.config_user(username)
         end
-        password = RHC::Config.password || RHC::get_password
+        config.password = config.password || RHC::get_password
 
-        RHC::Rest::Client.new(openshift_rest_node, username, password, @options.debug)
+        RHC::Rest::Client.new(openshift_rest_node, username, config.password, @options.debug)
       end
     end
 
+    def help(*args)
+      ac = Commander::Runner.instance.active_command
+      Commander::Runner.instance.command(:help).run(ac.name, *args)
+    end
+
+    def debug?
+      @options.debug
+    end
 
     class InvalidCommand < StandardError ; end
 
@@ -106,7 +127,7 @@ class RHC::Commands::Base
       return if private_method_defined? method
       return if protected_method_defined? method
 
-      method_name = method.to_s == 'run' ? nil : method.to_s
+      method_name = method.to_s == 'run' ? nil : method.to_s.gsub("_", "-")
       name = [method_name]
       name.unshift(self.object_name).compact!
       raise InvalidCommand, "Either object_name must be set or a non default method defined" if name.empty?
@@ -115,6 +136,7 @@ class RHC::Commands::Base
         :class => self,
         :method => method
       }));
+
       @options = nil
     end
 
@@ -127,8 +149,8 @@ class RHC::Commands::Base
         end
     end
 
-    def self.description(value)
-      options[:description] = value
+    def self.description(*args)
+      options[:description] = args.join(' ')
     end
     def self.summary(value)
       options[:summary] = value
@@ -136,7 +158,9 @@ class RHC::Commands::Base
     def self.syntax(value)
       options[:syntax] = value
     end
-
+    def self.deprecated(msg)
+      options[:deprecated] = msg
+    end
     def self.suppress_wizard
       @suppress_wizard = true
     end
@@ -159,7 +183,8 @@ class RHC::Commands::Base
       options_metadata << {:switches => switches,
                            :description => description,
                            :context_helper => options[:context],
-                           :required => options[:required]
+                           :required => options[:required],
+                           :deprecated => options[:deprecated]
                           }
     end
 
@@ -168,7 +193,12 @@ class RHC::Commands::Base
       raise ArgumentError("Only the last argument descriptor for an action can be a list") if arg_type == :list and list_argument_defined?
       list_argument_defined true if arg_type == :list
 
-      args_metadata << {:name => name, :description => description, :switches => switches, :arg_type => arg_type}
+      option_symbol = Commander::Runner.switch_to_sym(switches.last)
+      args_metadata << {:name => name,
+                        :description => description,
+                        :switches => switches,
+                        :option_symbol => option_symbol,
+                        :arg_type => arg_type}
     end
 
     def self.default_action(action)

data/lib/rhc/commands/cartridge.rb

@@ -0,0 +1,189 @@
+require 'rhc/commands/base'
+require 'rhc/cartridge_helper'
+
+module RHC::Commands
+  class Cartridge < Base
+    summary "Manage your application cartridges"
+    syntax "<action>"
+    alias_action :"app cartridge", :root_command => true, :deprecated => true
+    default_action :list
+
+    summary "List supported embedded cartridges"
+    alias_action :"app cartridge list", :root_command => true, :deprecated => true
+    def list
+      carts = rest_client.find_cartridges(:type => 'embedded').collect { |c| c.name }
+      results { say "#{carts.join(', ')}" }
+      0
+    end
+
+    summary "Add a cartridge to your application"
+    syntax "<cartridge_type> [--namespace namespace] [--app app]"
+    option ["-n", "--namespace namespace"], "Namespace of the application you are adding the cartridge to", :context => :namespace_context, :required => true
+    option ["-a", "--app app"], "Application you are adding the cartridge to", :context => :app_context, :required => true
+    argument :cart_type, "The type of the cartridge you are adding (run 'rhc cartridge list' to obtain a list of available cartridges)", ["-c", "--cartridge cart_type"]
+    alias_action :"app cartridge add", :root_command => true, :deprecated => true
+    def add(cart_type)
+      cart = find_cartridge rest_client, cart_type
+
+      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_cartridge = rest_app.add_cartridge(cart.name)
+      say "Success"
+
+      display_cart(rest_cartridge,rest_cartridge.properties[:cart_data])
+
+      0
+    end
+
+    summary "Show useful information about a cartridge"
+    syntax "<cartridge> [--namespace namespace] [--app app]"
+    option ["-n", "--namespace namespace"], "Namespace of the application you are adding the cartridge to", :context => :namespace_context, :required => true
+    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_cartridge = find_cartridge rest_app, cartridge, nil
+
+      display_cart(rest_cartridge,rest_cartridge.properties[:cart_data])
+
+      0
+    end
+
+    summary "Remove a cartridge from your application"
+    syntax "<cartridge> [--namespace namespace] [--app app]"
+    argument :cartridge, "The name of the cartridge you are removing", ["-c", "--cartridge cartridge"]
+    option ["-n", "--namespace namespace"], "Namespace of the application you are removing the cartridge from", :context => :namespace_context, :required => true
+    option ["-a", "--app app"], "Application you are removing the cartridge from", :context => :app_context, :required => true
+    option ["--confirm"], "Safety switch - if this switch is not passed a warning is printed out and the cartridge will not be removed"
+    alias_action :"app cartridge remove", :root_command => true, :deprecated => true
+    def remove(cartridge)
+      unless options.confirm
+        results { say "Removing a cartridge is a destructive operation that may result in loss of data associated with the cartridge.  You must pass the --confirm switch to this command in order to to remove the cartridge." }
+        return 1
+      end
+
+      rest_domain = rest_client.find_domain(options.namespace)
+      rest_app = rest_domain.find_application(options.app)
+      rest_cartridge = rest_app.find_cartridge cartridge, :type => "embedded"
+      rest_cartridge.destroy
+
+      results { say "Success: Cartridge '#{rest_cartridge.name}' removed from application '#{rest_app.name}'." }
+      0
+    end
+
+    summary "Start a cartridge"
+    syntax "<cartridge> [--namespace namespace] [--app app]"
+    argument :cart_type, "The name of the cartridge you are stopping", ["-c", "--cartridge cartridge"]
+    option ["-n", "--namespace namespace"], "Namespace of the application the cartrdige belongs to", :context => :namespace_context, :required => true
+    option ["-a", "--app app"], "Application the cartridge", :context => :app_context, :required => true
+    alias_action :"app cartridge start", :root_command => true, :deprecated => true
+    def start(cartridge)
+      cartridge_action cartridge, :start
+
+      results { say "#{cartridge} started!" }
+      0
+    end
+
+    summary "Stop a cartridge"
+    syntax "<cartridge> [--namespace namespace] [--app app]"
+    argument :cart_type, "The name of the cartridge you are stopping", ["-c", "--cartridge cartridge"]
+    option ["-n", "--namespace namespace"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
+    option ["-a", "--app app"], "Application you the cartridge belongs to", :context => :app_context, :required => true
+    alias_action :"app cartridge stop", :root_command => true, :deprecated => true
+    def stop(cartridge)
+      cartridge_action cartridge, :stop
+
+      results { say "#{cartridge} stopped!" }
+      0
+    end
+
+    summary "Restart a cartridge"
+    syntax "<cartridge_type> [--namespace namespace] [--app app]"
+    argument :cart_type, "The name of the cartridge you are restarting", ["-c", "--cartridge cartridge"]
+    option ["-n", "--namespace namespace"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
+    option ["-a", "--app app"], "Application the cartridge belongs to", :context => :app_context, :required => true
+    alias_action :"app cartridge restart", :root_command => true, :deprecated => true
+    def restart(cartridge)
+      cartridge_action cartridge, :restart
+
+      results { say "#{cartridge} restarted!" }
+      0
+    end
+
+    summary "Get current the status of a cartridge"
+    syntax "<cartridge> [--namespace namespace] [--app app]"
+    argument :cart_type, "The name of the cartridge you are getting the status of", ["-c", "--cartridge cartridge"]
+    option ["-n", "--namespace namespace"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
+    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_cartridge = find_cartridge(rest_app, cartridge)
+      msgs = rest_cartridge.status
+      results {
+        msgs.each do |msg|
+          say msg['message']
+        end
+      }
+      0
+    end
+
+    summary "Reload the cartridge's configuration"
+    syntax "<cartridge> [--namespace namespace] [--app app]"
+    argument :cart_type, "The name of the cartridge you are reloading", ["-c", "--cartridge cartridge"]
+    option ["-n", "--namespace namespace"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
+    option ["-a", "--app app"], "Application the cartridge belongs to", :context => :app_context, :required => true
+    alias_action :"app cartridge reload", :root_command => true, :deprecated => true
+    def reload(cartridge)
+      cartridge_action cartridge, :reload
+
+      results { say "#{cartridge} config reloaded!" }
+      0
+    end
+
+    summary "Set the scaling range of a cartridge"
+    syntax "<cartridge> [--timeout timeout] [--namespace namespace] [--app app] [--min min] [--max max]"
+    argument :cart_type, "The name of the cartridge you are reloading", ["-c", "--cartridge cartridge"]
+    option ["-n", "--namespace namespace"], "Namespace of the application the cartridge belongs to", :context => :namespace_context, :required => true
+    option ["-a", "--app app"], "Application the cartridge belongs to", :context => :app_context, :required => true
+    option ["--timeout timeout"], "Timeout, in seconds, for the session"
+    option ["--min min", Integer], "Minimum scaling value"
+    option ["--max max", Integer], "Maximum scaling value"
+    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_cartridge = find_cartridge rest_app, cartridge, nil
+
+      raise RHC::CartridgeNotScalableException unless rest_cartridge.scalable?
+
+      cart = rest_cartridge.set_scales({
+        :scales_from => options.min,
+        :scales_to   => options.max
+      })
+
+      results do
+        say "Success: Scaling values updated"
+        display_cart(cart)
+      end
+
+      0
+    end
+
+    private
+    include RHC::CartridgeHelpers
+
+    def cartridge_action(cartridge, action)
+      rest_domain = rest_client.find_domain(options.namespace)
+      rest_app = rest_domain.find_application(options.app)
+      rest_cartridge = find_cartridge rest_app, cartridge
+      result = rest_cartridge.send action
+      [result, rest_cartridge, rest_app, rest_domain]
+    end
+  end
+end

data/lib/rhc/commands/domain.rb

@@ -7,9 +7,8 @@ module RHC::Commands
     default_action :show
 
     summary "Define a namespace for your applications to share."
-    syntax "<namespace> [--timeout timeout]"
+    syntax "<namespace>"
     argument :namespace, "Namespace for your application(s) (alphanumeric)", ["-n", "--namespace namespace"]
-    option ["--timeout timeout"], "Timeout, in seconds, for the session"
     def create(namespace)
       paragraph { say "Creating domain with namespace '#{namespace}'" }
       rest_client.add_domain(namespace)
@@ -23,21 +22,16 @@ module RHC::Commands
     end
 
     summary "Change current namespace (will change application urls)"
-    syntax "<namespace> [--timeout timeout]"
-    argument :namespace, "Namespace to change", ["-n", "--namespace namespace"]
-    option ["--timeout timeout"], "Timeout, in seconds, for the session"
+    syntax "<old namespace> <new namespace>"
+    argument :old_namespace, "Old namespace to change", []
+    argument :new_namespace, "New namespace to change", ["-n", "--namespace namespace"]
     alias_action :alter
-    def update(namespace)
-      # TODO: Support multiple domains.  Right now we assume one domain so
-      #       you don't have to send in the name of the domain you want to change
-      #       but in the future this will be manditory if you have more than one
-      #       domain.  Figure out how to support overloading of commands
-      domain = rest_client.domains
-      raise RHC::DomainNotFoundException, "No domains are registered to the user #{config.username}. Please use 'rhc domain create' to create one." if domain.empty?
+    def update(old_namespace, new_namespace)
+      domain = rest_client.find_domain(old_namespace)
 
-      say "Changing namespace '#{domain[0].id}' to '#{namespace}'..."
+      say "Changing namespace '#{domain.id}' to '#{new_namespace}'..."
 
-      domain[0].update(namespace)
+      domain.update(new_namespace)
 
       results do
         say "Success!"
@@ -51,43 +45,12 @@ module RHC::Commands
     def show
       domain = rest_client.domains.first
 
-      if domain
-        paragraph do
-          say "Applications in #{domain.id}:"
-          apps = domain.applications
-          if apps.length == 0
-            say "No applications.  You can use 'rhc app create' to create new applications."
-          else
-            apps.each_with_index do |a,i|
-              carts = a.cartridges
-              section(:top => (i == 0 ? 1 : 2)) do
-                header "%s @ %s" % [a.name, a.app_url]
-                say "Created: #{date(a.creation_time)}"
-                #say "         UUID: #{a.uuid}"
-                say "Git URL: #{a.git_url}" if a.git_url
-                say "Aliases: #{a.aliases.join(', ')}" if a.aliases and not a.aliases.empty?
-                if carts.present?
-                  say "\nCartridges:"
-                  carts.each do |c|
-                    connection_url = c.property(:cart_data, :connection_url) || c.property(:cart_data, :job_url) || c.property(:cart_data, :monitoring_url)
-                    value = connection_url ? " - #{connection_url['value']}" : ""
-                    say "  #{c.name}#{value}"
-                  end
-                else
-                  say "Cartridges: none"
-                end
-              end
-            end
-          end
-        end
-      else
-        say "No domain exists.  You can use 'rhc domain create' to create a namespace for applications." unless domain
-      end
+      display_domain(domain)
+
       0
     end
 
     summary "Run a status check on your domain"
-    option ["--timeout timeout"], "Timeout, in seconds, for the session"
     def status
       args = []
 
@@ -102,9 +65,8 @@ module RHC::Commands
     end
 
     summary "Deletes your domain."
-    syntax "<namespace> [--timeout timeout]"
+    syntax "<namespace>"
     argument :namespace, "Namespace you wish to destroy", ["-n", "--namespace namespace"]
-    option ["--timeout timeout"], "Timeout, in seconds, for the session"
     alias_action :destroy
     def delete(namespace)
       domain = rest_client.find_domain namespace

data/lib/rhc/commands/port-forward.rb

@@ -9,7 +9,6 @@ module RHC::Commands
     summary "Forward remote ports to the workstation"
     option ["-n", "--namespace namespace"], "Namespace of the application you are port forwarding to", :context => :namespace_context, :required => true
     argument :app, "Application you are port forwarding to (required)", ["-a", "--app app"]
-    option ["--timeout timeout"], "Timeout, in seconds, for the session"
     def run(app)
 
       rest_domain = rest_client.find_domain options.namespace

data/lib/rhc/commands/setup.rb

@@ -8,7 +8,8 @@ module RHC::Commands
 
     summary "Easy to use wizard for getting started with OpenShift."
     def run
-      RHC::RerunWizard.new(config).run ?  0 : 1
+      raise OptionParser::InvalidOption, "Setup can not be run with the --noprompt option" if options.noprompt
+      RHC::RerunWizard.new(config, options).run ?  0 : 1
     end
   end
 end

data/lib/rhc/commands/snapshot.rb

@@ -0,0 +1,118 @@
+require 'rhc/commands/base'
+
+module RHC::Commands
+  class Snapshot < Base
+    summary "Pull down application snapshot for a user."
+    syntax "<action>"
+    alias_action :"app snapshot", :root_command => true
+    default_action :help
+
+    summary "Pull down application snapshot for the specified application."
+    syntax "<application>"
+    option ["-n", "--namespace namespace"], "Namespace of the application you are saving a snapshot", :context => :namespace_context, :required => true
+    option ["-f", "--filepath filepath"], "Local path to save tarball (default: ./$APPNAME.tar.gz)"
+    argument :app, "Application you are saving a snapshot (required)", ["-a", "--app app"]
+    alias_action :"app snapshot save", :root_command => true, :deprecated => true
+    def save(app)
+      ssh_uri = URI.parse(rest_client.find_domain(options.namespace).find_application(app).ssh_url)
+      filename = options.filepath ? options.filepath : "#{app}.tar.gz"
+
+      ssh_cmd = "ssh #{ssh_uri.user}@#{ssh_uri.host} 'snapshot' > #{filename}"
+      debug ssh_cmd
+
+      say "Pulling down a snapshot to #{filename}..."
+
+      begin
+
+        if ! RHC::Helpers.windows?
+          output = Kernel.send(:`, ssh_cmd)
+          if $?.exitstatus != 0
+            debug output
+            raise RHC::SnapshotSaveException.new "Error in trying to save snapshot. You can try to save manually by running:\n#{ssh_cmd}"
+          end
+        else
+          Net::SSH.start(ssh_uri.host, ssh_uri.user) do |ssh|
+            File.open(filename, 'wb') do |file|
+              ssh.exec! "snapshot" do |channel, stream, data|
+                if stream == :stdout
+                  file.write(data)
+                else
+                  debug data
+                end
+              end
+            end
+          end
+        end
+      rescue Timeout::Error, Errno::EADDRNOTAVAIL, Errno::EADDRINUSE, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Net::SSH::AuthenticationFailed => e
+        debug e.backtrace
+        raise RHC::SnapshotSaveException.new "Error in trying to save snapshot. You can try to save manually by running:\n#{ssh_cmd}"
+      end
+      results { say "Success" }
+      0
+    end
+
+    summary "Restores a previously saved snapshot."
+    syntax "<application>"
+    option ["-n", "--namespace namespace"], "Namespace of the application you are saving a snapshot", :context => :namespace_context, :required => true
+    option ["-f", "--filepath filepath"], "Local path to save tarball (default: ./$APPNAME.tar.gz)"
+    argument :app, "Application you are saving a snapshot (required)", ["-a", "--app app"]
+    alias_action :"app snapshot restore", :root_command => true, :deprecated => true
+    def restore(app)
+
+      filename = options.filepath ? options.filepath : "#{app}.tar.gz"
+
+      if File.exists? filename
+
+        include_git = RHC::Helpers.windows? ? true : RHC::TarGz.contains(filename, './*/git')
+
+        ssh_uri = URI.parse(rest_client.find_domain(options.namespace).find_application(app).ssh_url)
+
+        ssh_cmd = "cat #{filename} | ssh #{ssh_uri.user}@#{ssh_uri.host} 'restore#{include_git ? ' INCLUDE_GIT' : ''}'"
+
+        say "Restoring from snapshot #{filename}..."
+        debug ssh_cmd
+
+        begin
+          if ! RHC::Helpers.windows?
+            output = Kernel.` ssh_cmd
+            if $?.exitstatus != 0
+              debug output
+              raise RHC::SnapshotRestoreException.new "Error in trying to restore snapshot. You can try to restore manually by running:\n#{ssh_cmd}"
+            end
+          else
+            ssh = Net::SSH.start(ssh_uri.host, ssh_uri.user)
+            ssh.open_channel do |channel|
+              channel.exec("restore#{include_git ? ' INCLUDE_GIT' : ''}") do |ch, success|
+                channel.on_data do |ch, data|
+                  say data
+                end
+                channel.on_extended_data do |ch, type, data|
+                  say data
+                end
+                channel.on_close do |ch|
+                  say "Terminating..."
+                end
+                File.open(filename, 'rb') do |file|
+                  file.chunk(1024) do |chunk|
+                    channel.send_data chunk
+                  end
+                end
+                channel.eof!
+              end
+            end
+            ssh.loop
+          end
+        rescue Timeout::Error, Errno::EADDRNOTAVAIL, Errno::EADDRINUSE, Errno::EHOSTUNREACH, Errno::ECONNREFUSED, Net::SSH::AuthenticationFailed => e
+          debug e.backtrace
+          raise RHC::SnapshotRestoreException.new "Error in trying to restore snapshot. You can try to restore manually by running:\n#{ssh_cmd}"
+        end
+
+      else
+        raise RHC::SnapshotRestoreException.new "Archive not found: #{filename}"
+      end
+      results { say "Success" }
+      0
+    end
+
+  end
+end

data/lib/rhc/commands/sshkey.rb

@@ -5,65 +5,58 @@ require 'rhc/commands/base'
 module RHC::Commands
   class Sshkey < Base
     include RHC::SSHKeyHelpers
-    
+
     summary 'Manage multiple keys for the registered rhcloud user.'
     syntax '<action>'
     default_action :list
-    
+
     summary 'Display all the SSH keys for the user account'
     syntax ''
-    option ["--timeout timeout"], "Timeout, in seconds, for the session"
     def list
-      ssh_keys = rest_client.sshkeys
       results do
-        result = ''
-
-        ssh_keys.each do |key|
-          result += format(key, erb)
+        result = rest_client.sshkeys.inject('') do |r, key|
+          r += format(key, erb)
         end
-        
+
         say result
       end
-      
+
       0
     end
-    
+
     summary 'List the SSH key with the given name'
     syntax '<name>'
     argument :name, 'SSH key to display', []
-    option ["--timeout timeout"], "Timeout, in seconds, for the session"
     def show(name)
       key = rest_client.find_key(name)
       say format(key, erb)
-      
+
       0
     end
 
     summary 'Add SSH key to the user account'
-    syntax '<name> <SSH Key file>'
+    syntax '<name> <path to SSH key file>'
     argument :name, 'Name for this key', []
     argument :key, 'SSH public key filepath', []
-    option ["--timeout timeout"], "Timeout, in seconds, for the session"
+    option ['--confirm'], 'Bypass key validation'
     def add(name, key)
-      begin
-        file = File.open(key)
-      rescue Errno::ENOENT => e
-        raise ::RHC::KeyFileNotExistentException.new("File '#{key}' does not exist.")
-      rescue Errno::EACCES => e
-        raise ::RHC::KeyFileAccessDeniedException.new("Access denied to '#{key}'.")
-      end
-      type, content, comment = file.gets.chomp.split
-      
+      type, content, comment = ssh_key_triple_for(key)
+
       # validate the user input before sending it to the server
       begin
         Net::SSH::KeyFactory.load_data_public_key "#{type} #{content}"
-      rescue NotImplementedError, Net::SSH::Exception => e
-        raise ::RHC::KeyDataInvalidException.new("File '#{key}' contains invalid data")
+      rescue NotImplementedError, OpenSSL::PKey::PKeyError, Net::SSH::Exception => e
+        debug e.inspect
+        if options.confirm
+          warn 'The key you are uploading is not recognized.  You may not be able to authenticate to your application through Git or SSH.'
+        else
+          raise ::RHC::KeyDataInvalidException.new("File '#{key}' does not appear to be a recognizable key file (#{e}). You may specify the '--confirm' flag to add the key anyway.")
+        end
       end
 
       rest_client.add_key(name, content, type)
       results { say "SSH key #{key} has been added as '#{name}'" }
-      
+
       0
     end
 
@@ -71,25 +64,18 @@ module RHC::Commands
     syntax '<name>'
     alias_action :delete
     argument :name, 'SSH key to remove', []
-    option ["--timeout timeout"], "Timeout, in seconds, for the session"
     def remove(name)
       rest_client.delete_key(name)
       results { say "SSH key '#{name}' has been removed" }
-      
+
       0
     end
-    
+
     private
     # shared ERB template for formatting SSH Key
     def erb
       return @erb if @erb # cache
-      @erb = ERB.new <<-FORMAT
-       Name: <%= key.name %>
-       Type: <%= key.type %>
-Fingerprint: <%= key.fingerprint %>
-
-      FORMAT
+      @erb = ::RHC::Helpers.ssh_key_display_format
     end
-    
   end
-end
+end