bosh_cli 0.19.6 → 1.0.rc1

data/bin/bosh

@@ -14,6 +14,9 @@ require "cli"
 begin
   Thread.abort_on_exception = true
   Bosh::Cli::Runner.run(ARGV.dup)
+rescue Errno::EPIPE
+  puts("pipe closed, exiting...")
+  exit(0)
 rescue Interrupt
   puts "\nExiting..."
   exit(1)

data/lib/cli.rb

@@ -3,7 +3,7 @@
 module Bosh
   module Cli
     DEFAULT_CONFIG_PATH = File.expand_path("~/.bosh_config")
-    DEFAULT_CACHE_DIR   = File.expand_path("~/.bosh_cache")
+    DEFAULT_CACHE_DIR = File.expand_path("~/.bosh_cache")
   end
 end
 
@@ -70,13 +70,23 @@ require "cli/release_tarball"
 
 require "cli/blob_manager"
 
-require "cli/command_definition"
+require "common/properties"
+require "cli/job_property_collection"
+require "cli/job_property_validator"
+
+require "cli/command_discovery"
+require "cli/command_handler"
 require "cli/runner"
+require "cli/base_command"
 
-YAML::ENGINE.yamler = 'syck' if defined?(YAML::ENGINE.yamler)
+if defined?(YAML::ENGINE.yamler)
+  YAML::ENGINE.yamler = "syck"
+end
 
-require File.expand_path(File.dirname(__FILE__) + "/cli/commands/base")
+tmpdir = Dir.mktmpdir
+at_exit { FileUtils.rm_rf(tmpdir) }
+ENV["TMPDIR"] = tmpdir
 
 Dir[File.dirname(__FILE__) + "/cli/commands/*.rb"].each do |file|
-  require File.expand_path(file)
+  require file
 end

data/lib/cli/{commands/base.rb → base_command.rb}

@@ -3,31 +3,50 @@
 module Bosh::Cli
   module Command
     class Base
-      attr_reader :cache, :config, :options, :work_dir
-      attr_accessor :out, :usage
+      extend Bosh::Cli::CommandDiscovery
+
+      attr_reader :options
+      attr_reader :work_dir
+      attr_reader :runner
+
+      attr_accessor :out
+
+      # @return [Array] Arguments passed to command handler
+      attr_accessor :args
 
       DEFAULT_DIRECTOR_PORT = 25555
 
-      def initialize(options = {})
-        @options = options.dup
+      # @param [Bosh::Cli::Runner] runner
+      def initialize(runner = nil)
+        @runner = runner
+        @options = {}
         @work_dir = Dir.pwd
-        config_file = @options[:config] || Bosh::Cli::DEFAULT_CONFIG_PATH
-        @config = Config.new(config_file)
-        @cache = Config.cache
         @exit_code = 0
         @out = nil
-        @usage = nil
+        @args = []
       end
 
-      class << self
-        attr_reader :commands
+      # @return [Bosh::Cli::Cache] Current CLI cache
+      def cache
+        Config.cache
+      end
 
-        def command(name, &block)
-          @commands ||= {}
-          @commands[name] = block
+      # @return [Bosh::Cli::Config] Current configuration
+      def config
+        @config ||= begin
+          config_file = options[:config] || Bosh::Cli::DEFAULT_CONFIG_PATH
+          Bosh::Cli::Config.new(config_file)
         end
       end
 
+      def add_option(name, value)
+        @options[name] = value
+      end
+
+      def remove_option(name)
+        @options.delete(name)
+      end
+
       def director
         @director ||= Bosh::Cli::Director.new(target, username, password)
       end
@@ -51,38 +70,24 @@ module Bosh::Cli
       end
 
       def non_interactive?
-        !interactive?
+        options[:non_interactive]
       end
 
       def interactive?
-        !options[:non_interactive]
+        !non_interactive?
       end
 
       def verbose?
-        options[:verbose]
-      end
-
-      # TODO: implement it
-      def dry_run?
-        options[:dry_run]
-      end
-
-      def show_usage
-        say("Usage: #{@usage}") if @usage
-      end
-
-      def run(namespace, action, *args)
-        eval(namespace.to_s.capitalize).new(options).send(action.to_sym, *args)
+        @options[:verbose]
       end
 
       def redirect(*args)
-        run(*args)
-        raise Bosh::Cli::GracefulExit, "redirected to %s" % [args.join(" ")]
+        Bosh::Cli::Runner.new(args, @options).run
       end
 
       def confirmed?(question = "Are you sure?")
-        non_interactive? ||
-          ask("#{question} (type 'yes' to continue): ") == "yes"
+        return true if non_interactive?
+        ask("#{question} (type 'yes' to continue): ") == "yes"
       end
 
       # @return [String] Target director URL
@@ -112,17 +117,6 @@ module Bosh::Cli
         config.target_name || target_url
       end
 
-      def target_version
-        config.target_version ? "Ver: " + config.target_version : ""
-      end
-
-      def full_target_name
-        # TODO refactor this method
-        ret = (target_name.blank? || target_name == target_url ?
-            target_name : "%s (%s)" % [target_name, target_url])
-        ret + " %s" % target_version if ret
-      end
-
       # Sets or returns command exit code
       # @param [optional,Integer] code If param is given, sets exit code. If
       #   it's nil, returns previously set exit_code

data/lib/cli/command_discovery.rb

@@ -0,0 +1,40 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli
+  module CommandDiscovery
+
+    def usage(string = nil)
+      @usage = string
+    end
+
+    def desc(string)
+      @desc = string
+    end
+
+    def option(name, *args)
+      (@options ||= []) << [name, args]
+    end
+
+    # @param [Symbol] method_name Method name
+    def method_added(method_name)
+      if @usage && @desc
+        @options ||= []
+        method = instance_method(method_name)
+        register_command(method, @usage, @desc, @options)
+      end
+      @usage = nil
+      @desc = nil
+      @options = []
+    end
+
+    # @param [UnboundMethod] method Method implementing the command
+    # @param [String] usage Command usage (used to parse command)
+    # @param [String] desc Command description
+    # @param [Array] options Command options
+    def register_command(method, usage, desc, options = [])
+      command = CommandHandler.new(self, method, usage, desc, options)
+      Bosh::Cli::Config.register_command(command)
+    end
+
+  end
+end

data/lib/cli/command_handler.rb

@@ -0,0 +1,135 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli
+  class CommandHandler
+
+    # @return [Array]
+    attr_reader :keywords
+
+    # @return [String]
+    attr_reader :usage
+
+    # @return [String]
+    attr_reader :desc
+
+    # @return [Bosh::Cli::Runner]
+    attr_accessor :runner
+
+    # @param [Class] klass
+    # @param [UnboundMethod] method
+    # @param [String] usage
+    # @param [String] desc
+    def initialize(klass, method, usage, desc, options = [])
+      @klass = klass
+      @method = method
+      @usage = usage
+      @desc = desc
+
+      @options = options
+
+      @hints = []
+      @keywords = []
+
+      @parser = OptionParser.new
+      @runner = nil
+      extract_keywords
+    end
+
+    # Run handler with provided args
+    # @param [Array] args
+    # @return [Integer] Command exit code
+    def run(args, extra_options = {})
+      handler = @klass.new(@runner)
+
+      @options.each do |(name, arguments)|
+        @parser.on(name, *arguments) do |value|
+          handler.add_option(format_option_name(name), value)
+        end
+      end
+
+      extra_options.each_pair do |name, value|
+        handler.add_option(format_option_name(name), value)
+      end
+
+      args = parse_options(args)
+
+      begin
+        handler.send(@method.name, *args)
+        handler.exit_code
+      rescue ArgumentError => e
+        say(e.message)
+        err("Usage: #{usage_with_params}")
+      end
+    end
+
+    def usage_with_params
+      result = [@usage]
+      @method.parameters.each do |parameter|
+        next if parameter.size < 2
+        kind, name = parameter
+        if kind == :opt
+          result << "[<#{name}>]"
+        elsif kind == :req
+          result << "<#{name}>"
+        end
+      end
+
+      @options.each do |(name, _)|
+        result << "[#{name}]"
+      end
+
+      result.join(" ")
+    end
+
+    def has_options?
+      @options.size > 0
+    end
+
+    def options_summary
+      result = []
+      padding = 5
+
+      margin = @options.inject(0) do |max, (name, _)|
+        [max, name.size].max
+      end
+
+      @options.each do |(name, desc)|
+        desc = desc.select { |word| word.is_a?(String) }
+        column_width = terminal_width - padding - margin
+
+        result << name.ljust(margin).yellow + " " +
+          desc.join(" ").columnize(
+            column_width, [margin + 1, name.size + 1].max)
+      end
+
+      result.join("\n")
+    end
+
+    # @param [Array] args Arguments to parse
+    def parse_options(args)
+      @parser.parse!(args)
+    end
+
+    private
+
+    def format_option_name(name)
+      case name
+      when Symbol
+        name
+      when String
+        name.split(/\s+/)[0].gsub(/^-*/, "").gsub("-", "_").to_sym
+      else
+        name
+      end
+    end
+
+    def extract_keywords
+      words = @usage.split(/\s+/)
+      words.each do |word|
+        break unless word.match(/^[a-z]/i)
+        @keywords << word
+      end
+    end
+
+  end
+end

data/lib/cli/commands/biff.rb

@@ -8,22 +8,26 @@ module Bosh::Cli::Command
     # are diff'd and the user can choose to keep the new config.
     # @param [String] template The string path to the template that should be
     #     used.
+    #
+    usage "diff"
+    desc "Diffs your current BOSH deployment configuration against " +
+         "the specified BOSH deployment configuration template so that " +
+         "you can keep your deployment configuration file up to date. " +
+         "A dev template can be found in deployments repos."
     def biff(template)
-      begin
-        setup(template)
+      setup(template)
 
-        template_to_fill = ERB.new(File.read(@template_file), 0, "%<>-")
-        @template_output = template_to_fill.result(binding)
+      template_to_fill = ERB.new(File.read(@template_file), 0, "%<>-")
+      @template_output = template_to_fill.result(binding)
 
-        if @errors == 0
-          print_string_diff(File.read(@deployment_file), @template_output)
-          keep_new_file unless @no_differences
-        else
-          say("There were " + "#{@errors} errors.".red)
-        end
-      ensure
-        delete_temp_diff_files
+      if @errors == 0
+        print_string_diff(File.read(@deployment_file), @template_output)
+        keep_new_file unless @no_differences
+      else
+        err("There were #{@errors} errors.")
       end
+    ensure
+      delete_temp_diff_files
     end
 
     private

data/lib/cli/commands/blob_management.rb

@@ -4,6 +4,8 @@ module Bosh::Cli::Command
   class BlobManagement < Base
 
     # Prints out blobs status
+    usage "blobs"
+    desc "Print current blobs status"
     def status
       blob_manager.print_status
     end
@@ -11,11 +13,13 @@ module Bosh::Cli::Command
     # Adds blob to managed blobs
     # @param [String] local_path Local file path
     # @param [optional, String] blob_dir Directory to store blob in, relative
-    #     to blobs dir
+    #   to blobs dir
+    usage "add blob"
+    desc "Add a local file as BOSH blob"
     def add(local_path, blob_dir = nil)
       blob_path = File.basename(local_path)
       if blob_dir
-        # We don't need about blobs prefix,
+        # We don't need 'blobs/' prefix,
         # but it might be handy for people who rely on auto-completion
         if blob_dir[0..5] == "blobs/"
           blob_dir = blob_dir[6..-1]
@@ -26,6 +30,8 @@ module Bosh::Cli::Command
     end
 
     # Uploads all blobs that need to be uploaded
+    usage "upload blobs"
+    desc "Upload new and updated blobs to the blobstore"
     def upload
       blob_manager.print_status
 
@@ -38,10 +44,11 @@ module Bosh::Cli::Command
     end
 
     # Syncs blobs with blobstore
+    usage "sync blobs"
+    desc "Sync blob with the blobstore"
     def sync
       blob_manager.sync
       blob_manager.print_status
     end
-
   end
 end

data/lib/cli/commands/cloudcheck.rb

@@ -4,23 +4,25 @@ module Bosh::Cli::Command
   class CloudCheck < Base
     include Bosh::Cli::DeploymentHelper
 
-    def perform(*options)
+    # bosh cloudcheck
+    usage "cloudcheck"
+    desc "Cloud consistency check and interactive repair"
+    option "--auto",
+           "resolve problems automatically ",
+           "(not recommended for production)"
+    option "--report",
+           "generate report only, ",
+           "don't attempt to resolve problems"
+    def perform(deployment_name = nil)
       auth_required
-      # TODO: introduce option helpers
-      deployment_name = options.shift unless options[0] =~ /^--/
-
-      @auto_mode = options.delete("--auto")
-      @report_mode = options.delete("--report")
+      @auto_mode = options[:auto]
+      @report_mode = options[:report]
 
       if non_interactive? && !@report_mode
         err ("Cloudcheck cannot be run in non-interactive mode\n" +
              "Please use `--auto' flag if you want automated resolutions")
       end
 
-      if options.size > 0
-        err("Unknown options: #{options.join(", ")}")
-      end
-
       if @auto_mode && @report_mode
         err("Can't use --auto and --report mode together")
       end
@@ -90,7 +92,7 @@ module Bosh::Cli::Command
 
       if @problems.empty?
         say("No problems found".green)
-        quit
+        exit(0)
       end
 
       @problems.each do |problem|