rhc 0.96.9 → 0.97.17

data/lib/rhc-rest/exceptions/exceptions.rb

@@ -70,6 +70,6 @@ module Rhc
     class ResourceAccessException < Rhc::Rest::BaseException; end
     #I/O Exceptions Connection timeouts, etc
     class ConnectionException < Rhc::Rest::BaseException; end
-
+    class TimeoutException < ConnectionException; end
   end
 end

data/lib/rhc-rest/key.rb

@@ -16,7 +16,7 @@ module Rhc
         url = @links['UPDATE']['href']
         method =  @links['UPDATE']['method']
         payload = {:type => type, :content => content}
-        request = RestClient::Request.new(:url => url, :method => method, :headers => @@headers, :payload => payload)
+        request = new_request(:url => url, :method => method, :headers => @@headers, :payload => payload)
         return request(request)
       end
 
@@ -25,7 +25,7 @@ module Rhc
         logger.debug "Deleting key #{self.name}" if @mydebug
         url = @links['DELETE']['href']
         method =  @links['DELETE']['method']
-        request = RestClient::Request.new(:url => url, :method => method, :headers => @@headers)
+        request = new_request(:url => url, :method => method, :headers => @@headers)
         return request(request)
       end
       alias :delete :destroy

data/lib/rhc-rest/user.rb

@@ -13,7 +13,7 @@ module Rhc
         url = @links['ADD_KEY']['href']
         method =  @links['ADD_KEY']['method']
         payload = {:name => name, :type => type, :content => content}
-        request = RestClient::Request.new(:url => url, :method => method, :headers => @@headers, :payload => payload)
+        request = new_request(:url => url, :method => method, :headers => @@headers, :payload => payload)
         return request(request)
       end
 
@@ -21,7 +21,7 @@ module Rhc
       def keys
         url = @links['LIST_KEYS']['href']
         method =  @links['LIST_KEYS']['method']
-        request = RestClient::Request.new(:url => url, :method => method, :headers => @@headers)
+        request = new_request(:url => url, :method => method, :headers => @@headers)
         return request(request)
       end
 

data/lib/rhc/cli.rb

@@ -18,7 +18,6 @@ module RHC
   # from the gem directory.
   #
   module CLI
-
     extend Commander::Delegates
 
     def self.set_terminal
@@ -26,13 +25,13 @@ module RHC
     end
 
     def self.start(args)
-      runner = Commander::Runner.new(args)
+      runner = RHC::Commands::Runner.new(args)
       Commander::Runner.instance_variable_set :@singleton, runner
 
       program :name,        'rhc'
       program :version,     RHC::VERSION::STRING
       program :description, 'Command line interface for OpenShift.'
-      program :help_formatter, :compact
+      program :help_formatter, RHC::UsageHelpFormatter
 
       RHC::Commands.load.to_commander
       exit(run! || 0)

data/lib/rhc/commands.rb

@@ -1,5 +1,102 @@
+require 'commander'
+require 'rhc/helpers'
+
 module RHC
-  module Commands 
+  module Commands
+    class CommandHelpBindings
+      def initialize(command, instance_commands, global_options)
+        @command = command
+        @actions = instance_commands.collect do |ic|
+          m = /^#{command.name} ([^ ]+)/.match(ic[0])
+          # if we have a match and it is not an alias then we can use it
+          m and ic[0] == ic[1].name ? {:name => m[1], :summary => ic[1].summary || ""} : nil
+        end
+        @actions.compact!
+        @global_options = global_options
+      end
+    end
+    class Runner < Commander::Runner
+      # regex fix from git - match on word boundries
+      def valid_command_names_from *args
+        arg_string = args.delete_if { |value| value =~ /^-/ }.join ' '
+        commands.keys.find_all { |name| name if /^#{name}\b/.match arg_string }
+      end
+
+      # override so we can do our own error handling
+      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)
+        global_option('-h', '--help', 'Display help documentation') do
+          args = @args - %w[-h --help]
+          command(:help).run(*args)
+          return
+        end
+        global_option('-v', '--version', 'Display version information') { say version; return }
+        global_option('-t', '--trace', 'Display backtrace when an error occurs') { trace = true }
+        parse_global_options
+        remove_global_options options, @args
+
+        # if help is last arg run as if --help was passed in
+        if @args[-1] == "help"
+          args = @args - ["help"]
+          command(:help).run(*args)
+          return
+        end
+
+        unless trace
+          begin
+            run_active_command
+          rescue InvalidCommandError => e
+            usage = RHC::UsageHelpFormatter.new(self).render
+            i = @args.find_index { |a| a.start_with?('-') } || @args.length
+            abort "The command 'rhc #{@args[0,i].join(' ')}' is not recognized.\n#{usage}"
+          rescue \
+            ArgumentError,
+            OptionParser::InvalidOption,
+            OptionParser::InvalidArgument,
+            OptionParser::MissingArgument => e
+
+            help_bindings = CommandHelpBindings.new(active_command, commands, Commander::Runner.instance.options)
+            usage = RHC::UsageHelpFormatter.new(self).render_command(help_bindings)
+            say "#{e}\n#{usage}"
+            1
+          rescue Rhc::Rest::BaseException => e
+            RHC::Helpers.results { say "#{e}" }
+            e.code.nil? ? 128 : e.code
+          rescue Exception => e
+            RHC::Helpers.results { say "error: #{e} Use --trace to view backtrace." }
+            128
+          end
+        else
+          run_active_command
+        end
+      end
+
+      def create_default_commands
+        command :help do |c|
+          c.syntax = 'rhc help <command>'
+          c.description = 'Display global or <command> help documentation.'
+          c.when_called do |args, options|
+            if args.empty?
+              say help_formatter.render
+            else
+              command = command args.join(' ')
+              begin
+                require_valid_command command
+              rescue InvalidCommandError => e
+                abort "#{e}"
+              end
+
+              help_bindings = CommandHelpBindings.new command, commands, Commander::Runner.instance.options
+              say help_formatter.render_command help_bindings
+            end
+          end
+        end
+      end
+    end
+
     def self.load
       Dir[File.join(File.dirname(__FILE__), "commands", "*.rb")].each do |file|
         require file
@@ -9,17 +106,70 @@ module RHC
     def self.add(opts)
       commands[opts[:name]] = opts
     end
-    def self.global_option(*args)
-      global_options << args
+    def self.global_option(switches, description)
+      global_options << [switches, description].flatten(1)
+    end
+    def self.validate_command(c, args, options, args_metadata)
+      # check to see if an arg's option was set
+      raise ArgumentError.new("Invalid arguments") if args.length > args_metadata.length
+      args_metadata.each_with_index do |arg_meta, i|
+        switch = arg_meta[:switches]
+        value = options.__hash__[arg_meta[:name]]
+        unless value.nil?
+          raise ArgumentError.new("#{arg_meta[:name]} specified twice on the command line and as a #{switch[0]} switch") unless args.length == i
+          # add the option as an argument
+          args << value
+        end
+      end
+    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.noprompt(options.noprompt) if options.noprompt
+      RHC::Config
+    end
+
+    def self.needs_configuration!(cmd, config)
+      # check to see if we need to run wizard
+      if not cmd.class.suppress_wizard?
+        w = RHC::Wizard.new config
+        return w.run if w.needs_configuration?
+      end
+      false
     end
+
     def self.to_commander(instance=Commander::Runner.instance)
       global_options.each{ |args| instance.global_option *args }
       commands.each_pair do |name, opts|
         instance.command name do |c|
           c.description = opts[:description]
           c.summary = opts[:summary]
+          c.syntax = opts[:syntax]
+
+          (opts[:options]||[]).each { |o| c.option *o }
+          args_metadata = opts[:args] || []
+          (args_metadata).each do |arg_meta|
+            arg_switches = arg_meta[:switches]
+            arg_switches << arg_meta[:description]
+            c.option *arg_switches unless arg_switches.nil?
+          end
+
           c.when_called do |args, options|
-            opts[:class].new(c, args, options).send(opts[:method])
+            validate_command c, args, options, args_metadata
+            config = global_config_setup options
+            cmd = opts[:class].new c, args, options, config
+            needs_configuration! cmd, config
+            cmd.send opts[:method], *args
+          end
+
+          unless opts[:aliases].nil?
+            opts[:aliases].each do |a|
+              alias_components = name.split(" ")
+              alias_components[-1] = a
+              instance.alias_command  "#{alias_components.join(' ')}", :"#{name}"
+            end
           end
         end
       end

data/lib/rhc/commands/base.rb

@@ -1,17 +1,27 @@
 require 'commander'
 require 'commander/delegates'
 require 'rhc/helpers'
+require 'rhc/wizard'
+require 'rhc/config'
+require 'rhc/commands'
+require 'rhc/exceptions'
 
 class RHC::Commands::Base
 
-  def initialize(command=nil, args=[], options=OptionParser.new)
-    @command, @args, @options = command, args, options
+  def initialize(command=nil,
+                 args=[],
+                 options=Commander::Command::Options.new,
+                 config=RHC::Config)
+    @command, @args, @options, @config = command, args, options, config
+
+    # apply timeout here even though it isn't quite a global
+    $rest_timeout = @options.timeout ? @options.timeout.to_i : nil
   end
 
   protected
     include RHC::Helpers
 
-    attr_reader :command, :args, :options
+    attr_reader :command, :args, :options, :config
 
     def application
       #@application ||= ... identify current application or throw,
@@ -33,15 +43,6 @@ class RHC::Commands::Base
       #                object).
     end
 
-    def config
-      @config ||= begin
-        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
-    end
-
     class InvalidCommand < StandardError ; end
 
     def self.inherited(klass)
@@ -81,9 +82,45 @@ class RHC::Commands::Base
     def self.summary(value)
       options[:summary] = value
     end
+    def self.syntax(value)
+      options[:syntax] = value
+    end
+
+    def self.suppress_wizard
+      @suppress_wizard = true
+    end
+
+    def self.suppress_wizard?
+      @suppress_wizard
+    end
+
+    def self.alias_action(action)
+      aliases << action
+    end
+
+    def self.option(switches, description)
+      options_metadata << [switches, description].flatten(1)
+    end
+
+    def self.argument(name, description, switches)
+      args_metadata << {:name => name, :description => description, :switches => switches}
+    end
+
+    def self.default_action(action)
+      define_method(:run) { |*args| send(action, *args) }
+    end
 
     private
+      def self.options_metadata
+        options[:options] ||= []
+      end
+      def self.args_metadata
+        options[:args] ||= []
+      end
       def self.options
         @options ||= {}
       end
+      def self.aliases
+        options[:aliases] ||= []
+      end
 end

data/lib/rhc/commands/domain.rb

@@ -0,0 +1,142 @@
+require 'rhc/commands/base'
+
+module RHC::Commands
+  class Domain < Base
+    summary "Manage your domain"
+    syntax "<action>"
+    default_action :show
+
+    summary "Bind a registered user to a domain"
+    syntax "<namespace> [--timeout timeout]"
+    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)
+
+      results do
+        say "Success!"
+        say "You may now create an application using the 'rhc app create' command"
+      end
+
+      0
+    end
+
+    summary "Update namespace (will change urls)."
+    syntax "<namespace> [--timeout timeout]"
+    argument :namespace, "Namespace for your application(s) (alphanumeric)", ["-n", "--namespace namespace"]
+    option ["--timeout timeout"], "Timeout, in seconds, for the session"
+    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.new("No domains are registered to the user #{config.username}. Please use 'rhc domain create' to create one.") if domain.empty?
+
+      paragraph { say "Updating domain '#{domain[0].id}' to namespace '#{namespace}'" }
+
+      domain[0].update(namespace)
+
+      results do
+        say "Success!"
+        say "You can use 'rhc domain show' to view any url changes.  Be sure to update any links including the url in your local git config: <local_git_repo>/.git/config"
+      end
+
+      0
+    end
+
+    summary "Show your configured domains"
+    def show
+      domains = rest_client.domains
+      paragraph do
+        say "User Info"
+        say "========="
+        if domains.length == 0
+          say "Namespace: No namespaces found. You can use 'rhc domain create <namespace>' to create a namespace for your applications."
+        elsif domains.length == 1
+          say "Namespace: #{domains[0].id}"
+        else
+          domains.each_with_index { |d, i| say "Namespace(#{i}): #{d.id}" }
+        end
+      end
+
+      paragraph { say "Login: #{config.username}" }
+      domains.each do |d|
+        paragraph do
+          header = "Namespace #{d.id}'s Applications"
+          say header
+          say "=" * header.length
+          apps = d.applications
+          if apps.length == 0
+            say "No applications found.  You can use 'rhc app create' to create new applications."
+          else
+            apps.each do |a|
+              carts = a.cartridges
+              paragraph do
+                say a.name
+                say "    Framework: #{carts[0].name}"
+                say "     Creation: #{a.creation_time}"
+                say "         UUID: #{a.uuid}"
+                say "      Git URL: #{a.git_url}" if a.git_url
+                say "   Public URL: #{a.app_url}" if a.app_url
+                say "      Aliases: #{a.aliases.join(', ')}" if a.aliases and not a.aliases.empty?
+                say "   Cartridges:"
+                if carts.length > 1
+                  carts.each do |c|
+                    if c.type == 'embedded'
+                      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
+                  end
+                else
+                  say "       None"
+                end
+              end
+            end
+          end
+        end
+      end
+      0
+    end
+
+    summary "Run a status check on your domain"
+    option ["--timeout timeout"], "Timeout, in seconds, for the session"
+    def status
+      args = []
+
+      options.__hash__.each do |key, value|
+        value = value.to_s
+        if value.length > 0 && value.to_s.strip.length == 0; value = "'#{value}'" end
+        args << "--#{key} #{value}"
+      end
+
+      Kernel.system("rhc-chk #{args.join(' ')} 2>&1")
+      $?.exitstatus.nil? ? 1 : $?.exitstatus
+    end
+
+    summary "Deletes your domain."
+    syntax "<namespace> [--timeout timeout]"
+    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)
+      paragraph { say "Deleting domain '#{namespace}'" }
+      domain = rest_client.find_domain namespace
+
+      paragraph do
+        begin
+          domain.destroy
+        rescue Rhc::Rest::ClientErrorException
+          raise Rhc::Rest::ClientErrorException.new("Domain contains applications. Delete applications first.", 128)
+        end
+      end
+
+      results { say "Success!" }
+      0
+    end
+  end
+
+end