bosh_cli 0.19.6 → 1.0.rc1

data/lib/cli/release.rb

@@ -64,6 +64,8 @@ module Bosh::Cli
       has_legacy_secret? ||
         has_blobstore_secrets?(bs, "atmos", "secret") ||
         has_blobstore_secrets?(bs, "simple", "user", "password") ||
+        has_blobstore_secrets?(bs, "swift", "rackspace") ||
+        has_blobstore_secrets?(bs, "swift", "hp") ||
         has_blobstore_secrets?(bs, "s3", "access_key_id", "secret_access_key")
     end
 

data/lib/cli/release_builder.rb

@@ -7,7 +7,7 @@ module Bosh::Cli
 
     DEFAULT_RELEASE_NAME = "bosh_release"
 
-    attr_reader :release, :packages, :jobs, :version
+    attr_reader :release, :packages, :jobs, :version, :build_dir
 
     # @param [Bosh::Cli::Release] release Current release
     # @param [Array<Bosh::Cli::PackageBuilder>] packages Built packages
@@ -23,7 +23,12 @@ module Bosh::Cli
       @dev_index = VersionsIndex.new(dev_releases_dir, release_name)
       @index = @final ? @final_index : @dev_index
 
-      create_release_build_dir
+      @build_dir = Dir.mktmpdir
+
+      in_build_dir do
+        FileUtils.mkdir("packages")
+        FileUtils.mkdir("jobs")
+      end
     end
 
     # @return [String] Release name
@@ -107,6 +112,7 @@ module Bosh::Cli
           "name" => package.name,
           "version" => package.version,
           "sha1" => package.checksum,
+          "fingerprint" => package.fingerprint,
           "dependencies" => package.dependencies
         }
       end
@@ -115,6 +121,7 @@ module Bosh::Cli
         {
           "name" => job.name,
           "version" => job.version,
+          "fingerprint" => job.fingerprint,
           "sha1" => job.checksum,
         }
       end
@@ -229,17 +236,6 @@ module Bosh::Cli
       end
     end
 
-    def build_dir
-      @build_dir ||= Dir.mktmpdir
-    end
-
-    def create_release_build_dir
-      in_build_dir do
-        FileUtils.mkdir("packages")
-        FileUtils.mkdir("jobs")
-      end
-    end
-
     def in_build_dir(&block)
       Dir.chdir(build_dir) { yield }
     end

data/lib/cli/release_compiler.rb

@@ -12,11 +12,10 @@ module Bosh::Cli
 
     # @param [String] manifest_file Release manifest path
     # @param [Bosh::Blobstore::Client] blobstore Blobstore client
-    # @param [Hash] remote_release Remote release info from director
     # @param [Array] package_matches List of package checksums that director
     #   can match
     # @param [String] release_dir Release directory
-    def initialize(manifest_file, blobstore, remote_release = nil,
+    def initialize(manifest_file, blobstore,
                    package_matches = [], release_dir = nil)
 
       @blobstore = blobstore
@@ -30,28 +29,11 @@ module Bosh::Cli
 
       @package_matches = Set.new(package_matches)
 
-      at_exit { FileUtils.rm_rf(@build_dir) }
-
       FileUtils.mkdir_p(@jobs_dir)
       FileUtils.mkdir_p(@packages_dir)
 
       @manifest = load_yaml_file(manifest_file)
 
-      if remote_release
-        # TODO: instead of OpenStruct conversion we should probably
-        # introduce proper abstractions for things below
-        @remote_packages = remote_release["packages"].map do |pkg|
-          OpenStruct.new(pkg)
-        end
-
-        @remote_jobs = remote_release["jobs"].map do |job|
-          OpenStruct.new(job)
-        end
-      else
-        @remote_packages = []
-        @remote_jobs = []
-      end
-
       @name = @manifest["name"]
       @version = @manifest["version"]
       @packages = @manifest["packages"].map { |pkg| OpenStruct.new(pkg) }
@@ -185,28 +167,17 @@ module Bosh::Cli
     # @return [Boolean]
     def remote_package_exists?(local_package)
       # If checksum is known to director we can always match it
-      return true if @package_matches.include?(local_package.sha1)
-
-      remote_object_exists?(@remote_packages, local_package)
+      @package_matches.include?(local_package.sha1) ||
+        (local_package.fingerprint &&
+         @package_matches.include?(local_package.fingerprint))
     end
 
     # Checks if local job is already known remotely
     # @param [#name, #version] local_job
     # @return [Boolean]
     def remote_job_exists?(local_job)
-      remote_object_exists?(@remote_jobs, local_job)
-    end
-
-    # @param [Enumerable] remote_objects Remote object collection
-    # @param [#name, #version] local_object
-    # @return [Boolean]
-    def remote_object_exists?(remote_objects, local_object)
-      remote_objects.any? do |remote_object|
-        remote_object.name == local_object.name &&
-          remote_object.version.to_s == local_object.version.to_s
-      end
+      false
     end
-
   end
 
 end

data/lib/cli/release_tarball.rb

@@ -32,25 +32,17 @@ module Bosh::Cli
 
     # Repacks tarball according to the structure of remote release
     # Return path to repackaged tarball or nil if repack has failed
-    def repack(remote_release = nil, package_matches = [])
+    def repack(package_matches = [])
       return nil unless valid?
       unpack
 
       tmpdir = Dir.mktmpdir
       repacked_path = File.join(tmpdir, "release-repack.tgz")
 
-      at_exit { FileUtils.rm_rf(tmpdir) }
-
       manifest = load_yaml_file(File.join(@unpack_dir, "release.MF"))
 
-      # Remote release could be not-existent, then package matches are supposed
-      # to satisfy everything
-      remote_release ||= {"jobs" => [], "packages" => []}
-
       local_packages = manifest["packages"]
       local_jobs = manifest["jobs"]
-      remote_packages = remote_release["packages"]
-      remote_jobs = remote_release["jobs"]
 
       @skipped = 0
 
@@ -61,8 +53,8 @@ module Bosh::Cli
         local_packages.each do |package|
           say("#{package["name"]} (#{package["version"]})".ljust(30), " ")
           if package_matches.include?(package["sha1"]) ||
-            remote_packages.any? { |rp| package["name"] == rp["name"] &&
-              package["version"].to_s == rp["version"].to_s }
+             (package["fingerprint"] &&
+              package_matches.include?(package["fingerprint"]))
             say("SKIP".green)
             @skipped += 1
             FileUtils.rm_rf(File.join("packages", "#{package["name"]}.tgz"))
@@ -73,14 +65,7 @@ module Bosh::Cli
 
         local_jobs.each do |job|
           say("#{job["name"]} (#{job["version"]})".ljust(30), " ")
-          if remote_jobs.any? { |rj| job["name"] == rj["name"] &&
-              job["version"].to_s == rj["version"].to_s }
-            say("SKIP".green)
-            @skipped += 1
-            FileUtils.rm_rf(File.join("jobs", "#{job["name"]}.tgz"))
-          else
-            say("UPLOAD".red)
-          end
+          say("UPLOAD".red)
         end
 
         return nil if @skipped == 0

data/lib/cli/runner.rb

@@ -6,667 +6,186 @@ module Bosh::Cli
   end
 
   class Runner
-    COMMANDS = { }
-    ALL_KEYWORDS = []
 
-    attr_reader :usage
-    attr_reader :namespace
-    attr_reader :action
+    # @return [Array]
     attr_reader :args
-    attr_reader :options
 
-    # The runner is an instance of the command type that the user issued,
-    # such as a Deployment instance.  This is an accessor for testing.
-    # @return [Bosh::Cli::Command::<type>] Instance of the command instance.
-    attr_accessor :runner
+    # @return [Hash]
+    attr_reader :options
 
+    # @param [Array] args
     def self.run(args)
       new(args).run
     end
 
-    def initialize(args)
+    # @param [Array] args
+    def initialize(args, options = {})
       @args = args
-      @options = {
-        :director_checks => true,
-        :colorize => true,
-      }
-    end
+      @options = options.dup
 
-    def prepare
-      define_commands
-      parse_options!
-      Config.output ||= STDOUT unless @options[:quiet]
-      Config.interactive = !@options[:non_interactive]
-      Config.colorize = @options.delete(:colorize)
-      Config.cache = Bosh::Cli::Cache.new(@options[:cache_dir] ||
-                                            Bosh::Cli::DEFAULT_CACHE_DIR)
+      banner = "Usage: bosh [<options>] <command> [<args>]"
+      @option_parser = OptionParser.new(banner)
 
-      define_plugin_commands
-      build_parse_tree
-      add_shortcuts
+      Config.colorize = true
+      Config.output ||= STDOUT
     end
 
+    # Find and run CLI command
+    # @return [void]
     def run
-      prepare
-      dispatch unless @namespace && @action
-
-      if @namespace && @action
-        ns_class_name = @namespace.to_s.gsub(/(?:_|^)(.)/) { $1.upcase }
-        klass = eval("Bosh::Cli::Command::#{ns_class_name}")
-        runner = klass.new(@options)
-        runner.usage = @usage
+      parse_global_options
 
-        action_arity = runner.method(@action.to_sym).arity
-        n_required_args = action_arity >= 0 ? action_arity : -action_arity - 1
+      Config.interactive = !@options[:non_interactive]
+      Config.cache = Bosh::Cli::Cache.new(@options[:cache_dir])
 
-        if n_required_args > @args.size
-          err("Not enough arguments, correct usage is: bosh #{@usage}")
-        end
-        if action_arity >= 0 && n_required_args < @args.size
-          err("Too many arguments, correct usage is: bosh #{@usage}")
-        end
+      build_parse_tree
+      load_plugins
+      add_shortcuts
 
-        runner.send(@action.to_sym, *@args)
-        exit(runner.exit_code)
-      elsif @args.empty? || @args == %w(help)
-        say(help_message)
-        say(plugin_help_message) if @plugins
-      elsif @args[0] == "complete"
-        unless ENV.has_key?('COMP_LINE')
-          $stderr.puts "COMP_LINE must be set when calling bosh complete"
-          exit(1)
-        end
-        line = ENV['COMP_LINE'].gsub(/^\S*bosh\s*/, '')
-        puts complete(line).join("\n")
+      if @args.empty?
+        say(usage)
         exit(0)
-      elsif @args[0] == "help"
-        cmd_args = @args[1..-1]
-        suggestions = command_suggestions(cmd_args).map do |cmd|
-          command_usage(cmd, 0)
-        end
-        if suggestions.empty?
-          unknown_command(cmd_args.join(" "))
-        else
-          say(suggestions.uniq.join("\n"))
-        end
-      else
-        unknown_command(@args.join(" "))
+      end
 
-        suggestions = command_suggestions(@args).map do |cmd|
-          "bosh #{cmd.usage}"
-        end
+      command = search_parse_tree(@parse_tree)
+      if command.nil? && Config.interactive
+        command = try_alias
+      end
+
+      if command.nil?
+        err("Unknown command: #{@args.join(" ")}")
+      end
 
-        if suggestions.size > 0
-          say("Did you mean any of these?")
-          say("\n" + suggestions.uniq.join("\n"))
+      command.runner = self
+      begin
+        exit_code = command.run(@args, @options)
+        exit(exit_code)
+      rescue OptionParser::ParseError => e
+        say(e.message.red)
+        say("Usage: bosh #{command.usage_with_params.columnize(60, 7)}")
+        if command.has_options?
+          say(command.options_summary.indent(7))
         end
-        exit(1)
       end
 
-    rescue OptionParser::InvalidOption => e
-      say(e.message.red + "\n" + basic_usage)
-      exit(1)
-    rescue Bosh::Cli::GracefulExit => e
-      # Redirected bosh commands end up
-      # generating this exception (kind of goto)
-    rescue Bosh::Cli::CliExit, Bosh::Cli::DirectorError => e
+    rescue OptionParser::ParseError => e
       say(e.message.red)
-      exit(e.exit_code)
+      say(@option_parser.to_s)
+      exit(1)
     rescue Bosh::Cli::CliError => e
-      say("Error #{e.error_code}: #{e.message}".red)
+      say(e.message.red)
       exit(e.exit_code)
-    rescue => e
-      if @options[:debug]
-        raise e
-      else
-        save_exception(e)
-        exit(1)
-      end
     end
 
-    # looks for command completion in the parse tree
-    def parse_tree_completion(node, words, index)
+    # Finds command completions in the parse tree
+    # @param [Array] words Completion prefix
+    # @param [Bosh::Cli::ParseTreeNode] node Current parse tree node
+    def find_completions(words, node = @parse_tree, index = 0)
       word = words[index]
 
       # exact match and not on the last word
       if node[word] && words.length != index
-        parse_tree_completion(node[word], words, index + 1)
+        find_completions(words, node[word], index + 1)
 
-      # exact match at the last word
+        # exact match at the last word
       elsif node[word]
         node[word].values
 
-      # find all partial matches
+        # find all partial matches
       else
         node.keys.grep(/^#{word}/)
       end
     end
 
-    # for use with:
-    # complete -C 'bosh complete' bosh
-    # @param [String] line command line (minus "bosh")
-    # @return [Array]
-    def complete(line)
-      words = line.split(/\s+/)
-      parse_tree_completion(@parse_tree, words, 0)
-    end
-
-    def command(name, &block)
-      cmd_def = CommandDefinition.new
-      cmd_def.instance_eval(&block)
-      COMMANDS[name] = cmd_def
-      ALL_KEYWORDS.push(*cmd_def.keywords)
-    end
-
-    def find_command(name)
-      COMMANDS[name] || raise("Unknown command definition: #{name}")
-    end
-
-    def dispatch(command = nil)
-      command ||= search_parse_tree(@parse_tree)
-      command = try_alias if command.nil? && Config.interactive
-      return if command.nil?
-      @usage = command.usage
-
-      case command.route
-        when Array
-          @namespace, @action = command.route
-        when Proc
-          @namespace, @action = command.route.call(@args)
-        else
-          raise "Command definition is invalid, " +
-                    "route should be an Array or Proc"
-      end
-    end
-
-    def define_commands
-      command :version do
-        usage "version"
-        desc  "Show version"
-        route :misc, :version
-      end
-
-      command :alias do
-        usage "alias <name> <command>"
-        desc  "Create an alias <name> for command <command>"
-        route :misc, :set_alias
-      end
-
-      command :list_aliases do
-        usage "aliases"
-        desc  "Show the list of available command aliases"
-        route :misc, :list_aliases
-      end
-
-      command :target do
-        usage "target [<name>] [<alias>]"
-        desc  "Choose director to talk to (optionally creating an alias). " +
-                  "If no arguments given, show currently targeted director"
-        route do |args|
-          (args.size > 0) ? [:misc, :set_target] : [:misc, :show_target]
-        end
-      end
-
-      command :list_targets do
-        usage "targets"
-        desc  "Show the list of available targets"
-        route :misc, :list_targets
-      end
-
-      command :deployment do
-        usage "deployment [<name>]"
-        desc  "Choose deployment to work with " +
-                  "(it also updates current target)"
-        route do |args|
-          if args.size > 0
-            [:deployment, :set_current]
-          else
-            [:deployment, :show_current]
-          end
-        end
-      end
-
-      command :deploy do
-        usage  "deploy"
-        desc   "Deploy according to the currently selected " +
-                   "deployment manifest"
-        option "--recreate", "recreate all VMs in deployment"
-        route  :deployment, :perform
-      end
-
-      command :edit_deployment do
-        usage  "edit deployment"
-        desc   "Edit current deployment manifest"
-        route  :deployment, :edit
-      end
-
-      command :ssh do
-        usage "ssh <job> [index] [<options>] [command]"
-        desc  "Given a job, execute the given command or " +
-              "start an interactive session"
-        option "--public_key <file>"
-        option "--gateway_host <host>"
-        option "--gateway_user <user>"
-        option "--default_password", "Use default ssh password. Not recommended."
-        route :ssh, :shell
-      end
-
-      command :ssh_cleanup do
-        usage "ssh_cleanup <job> [index]"
-        desc  "Cleanup SSH artifacts"
-        route :ssh, :cleanup
-      end
-
-      command :scp do
-        usage "scp <job> [index] (--upload|--download) [options]" +
-          "/path/to/source /path/to/destination"
-        desc  "upload/download the source file to the given job. " +
-          "Note: for dowload /path/to/destination is a directory"
-        option "--public_key <file>"
-        option "--gateway_host <host>"
-        option "--gateway_user <user>"
-        route :ssh, :scp
-      end
-
-      command :scp do
-        usage "scp <job> <--upload | --download> [options] " +
-                  "/path/to/source /path/to/destination"
-        desc  "upload/download the source file to the given job. " +
-                  "Note: for download /path/to/destination is a directory"
-        option "--index <job_index>"
-        option "--public_key <file>"
-        option "--gateway_host <host>"
-        option "--gateway_user <user>"
-        route :ssh, :scp
-      end
-
-      command :status do
-        usage "status"
-        desc  "Show current status (current target, " +
-                  "user, deployment info etc.)"
-        route :misc, :status
-      end
-
-      command :login do
-        usage "login [<name>] [<password>]"
-        desc  "Provide credentials for the subsequent interactions " +
-                  "with targeted director"
-        route :misc, :login
-      end
-
-      command :logout do
-        usage "logout"
-        desc  "Forget saved credentials for targeted director"
-        route :misc, :logout
-      end
-
-      command :purge do
-        usage "purge"
-        desc  "Purge local manifest cache"
-        route :misc, :purge_cache
-      end
-
-      command :create_release do
-        usage  "create release"
-        desc   "Create release (assumes current directory " +
-                   "to be a release repository)"
-        route  :release, :create
-        option "--force", "bypass git dirty state check"
-        option "--final", "create production-ready release " +
-            "(stores artefacts in blobstore, bumps final version)"
-        option "--with-tarball", "create full release tarball" +
-            "(by default only manifest is created)"
-        option "--dry-run", "stop before writing release " +
-            "manifest (for diagnostics)"
-      end
-
-      command :create_user do
-        usage "create user [<name>] [<password>]"
-        desc  "Create user"
-        route :user, :create
-      end
-
-      command :create_package do
-        usage "create package <name>|<path>"
-        desc  "Build a single package"
-        route :package, :create
-      end
-
-      command :start_job do
-        usage  "start <job> [<index>]"
-        desc   "Start job/instance"
-        route  :job_management, :start_job
-
-        power_option "--force"
-      end
-
-      command :stop_job do
-        usage  "stop <job> [<index>]"
-        desc   "Stop job/instance"
-        route  :job_management, :stop_job
-        option "--soft", "stop process only"
-        option "--hard", "power off VM"
-
-        power_option "--force"
-      end
-
-      command :restart_job do
-        usage  "restart <job> [<index>]"
-        desc   "Restart job/instance (soft stop + start)"
-        route  :job_management, :restart_job
-
-        power_option "--force"
-      end
-
-      command :recreate_job do
-        usage "recreate <job> [<index>]"
-        desc  "Recreate job/instance (hard stop + start)"
-        route :job_management, :recreate_job
-
-        power_option "--force"
-      end
-
-      command :rename_job do
-        usage "rename <old_job_name> <new_job_name>"
-        desc  "renames a job. NOTE, your deployment manifest must also be " +
-              "updated to reflect the new job name."
-        power_option "--force"
-
-        route :job_rename, :rename
-      end
-
-      command :fetch_logs do
-        usage  "logs <job> <index>"
-        desc   "Fetch job (default) or agent (if option provided) logs"
-        route  :log_management, :fetch_logs
-        option "--agent", "fetch agent logs"
-        option "--only <filter1>[...]", "only fetch logs that satisfy " +
-            "given filters (defined in job spec)"
-        option "--all", "fetch all files in the job or agent log directory"
-      end
-
-      command :set_property do
-        usage "set property <name> <value>"
-        desc  "Set deployment property"
-        route :property_management, :set
-      end
-
-      command :get_property do
-        usage "get property <name>"
-        desc  "Get deployment property"
-        route :property_management, :get
-      end
-
-      command :unset_property do
-        usage "unset property <name>"
-        desc  "Unset deployment property"
-        route :property_management, :unset
-      end
-
-      command :list_properties do
-        usage  "properties"
-        desc   "List current deployment properties"
-        route  :property_management, :list
-        option "--terse", "easy to parse output"
-      end
-
-      command :init_release do
-        usage "init release [<path>]"
-        desc  "Initialize release directory"
-        route :release, :init
-        option "--git", "initialize git repository"
-      end
-
-      command :generate_package do
-        usage "generate package <name>"
-        desc  "Generate package template"
-        route :package, :generate
-      end
-
-      command :generate_job do
-        usage "generate job <name>"
-        desc  "Generate job template"
-        route :job, :generate
-      end
-
-      command :upload_stemcell do
-        usage "upload stemcell <path>"
-        desc  "Upload the stemcell"
-        route :stemcell, :upload
-      end
-
-      command :upload_release do
-        usage "upload release [<path>]"
-        desc  "Upload release (<path> can point to tarball or manifest, " +
-                  "defaults to the most recently created release)"
-        route :release, :upload
-      end
-
-      command :verify_stemcell do
-        usage "verify stemcell <path>"
-        desc  "Verify stemcell"
-        route :stemcell, :verify
-      end
-
-      command :verify_release do
-        usage "verify release <path>"
-        desc  "Verify release"
-        route :release, :verify
-      end
-
-      command :delete_deployment do
-        usage "delete deployment <name>"
-        desc  "Delete deployment"
-        route :deployment, :delete
-        option "--force", "ignore all errors while deleting parts " +
-            "of the deployment"
-      end
-
-      command :delete_stemcell do
-        usage "delete stemcell <name> <version>"
-        desc  "Delete the stemcell"
-        route :stemcell, :delete
-      end
-
-      command :delete_release do
-        usage  "delete release <name> [<version>]"
-        desc   "Delete release (or a particular release version)"
-        route  :release, :delete
-        option "--force", "ignore errors during deletion"
-      end
-
-      command :reset_release do
-        usage "reset release"
-        desc  "Reset release development environment " +
-                  "(deletes all dev artifacts)"
-        route :release, :reset
-      end
-
-      command :cancel_task do
-        usage "cancel task <id>"
-        desc  "Cancel task once it reaches the next cancel checkpoint"
-        route :task, :cancel
-      end
-
-      command :track_task do
-        usage  "task [<task_id>|last]"
-        desc   "Show task status and start tracking its output"
-        route  :task, :track
-        option "--no-cache", "don't cache output locally"
-        option "--event|--soap|--debug", "different log types to track"
-        option "--raw", "don't beautify log"
-      end
-
-      command :list_stemcells do
-        usage "stemcells"
-        desc  "Show the list of available stemcells"
-        route :stemcell, :list
-      end
-
-      command :list_public_stemcells do
-        usage "public stemcells"
-        desc  "Show the list of publicly available stemcells for download."
-        route :stemcell, :list_public
-        option "--full", "show the full download url"
+    def parse_global_options
+      # -v is reserved for verbose but having 'bosh -v' is handy,
+      # hence the little hack
+      if @args.size == 1 && (@args[0] == "-v" || @args[0] == "--version")
+        @args = %w(version)
+        return
       end
 
-      command :download_public_stemcell do
-        usage "download public stemcell <stemcell_name>"
-        desc  "Downloads a stemcell from the public blobstore."
-        route :stemcell, :download_public
+      opts = @option_parser
+      opts.on("-c", "--config FILE", "Override configuration file") do |file|
+        @options[:config] = file
       end
-
-      command :list_releases do
-        usage "releases"
-        desc  "Show the list of available releases"
-        route :release, :list
+      opts.on("-C", "--cache-dir DIR", "Override cache directory") do |dir|
+        @options[:cache_dir] = dir
       end
-
-      command :list_deployments do
-        usage "deployments"
-        desc  "Show the list of available deployments"
-        route :deployment, :list
+      opts.on("--[no-]color", "Toggle colorized output") do |v|
+        Config.colorize = v
       end
 
-      command :diff do
-        usage "diff [<template_file>]"
-        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."
-        route :biff, :biff
+      opts.on("-v", "--verbose", "Show additional output") do
+        @options[:verbose] = true
       end
-
-      command :list_running_tasks do
-        usage "tasks"
-        desc  "Show the list of running tasks"
-        route :task, :list_running
+      opts.on("-q", "--quiet", "Suppress all output") do
+        Config.output = nil
       end
-
-      command :list_recent_tasks do
-        usage "tasks recent [<number>]"
-        desc  "Show <number> recent tasks"
-        route :task, :list_recent
+      opts.on("-n", "--non-interactive", "Don't ask for user input") do
+        @options[:non_interactive] = true
+        Config.colorize = false
       end
-
-      command :list_vms do
-        usage "vms [<deployment>]"
-        desc  "List all VMs that supposed to be in a deployment"
-        route :vms, :list
+      opts.on("-t", "--target URL", "Override target") do |target|
+        @options[:target] = target
       end
-
-      command :cleanup do
-        usage "cleanup"
-        desc  "Remove all but several recent stemcells and releases " +
-                  "from current director " +
-                  "(stemcells and releases currently in use are NOT deleted)"
-        route :maintenance, :cleanup
+      opts.on("-u", "--user USER", "Override username") do |user|
+        @options[:username] = user
       end
-
-      command :cloudcheck do
-        usage  "cloudcheck [<deployment>]"
-        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"
-        route  :cloud_check, :perform
+      opts.on("-p", "--password PASSWORD", "Override password") do |pass|
+        @options[:password] = pass
       end
-
-      command :add_blob do
-        usage  "add blob <local_path> [<blob_dir>]"
-        desc   "Add a local file as BOSH blob"
-        route  :blob_management, :add
+      opts.on("-d", "--deployment FILE", "Override deployment") do |file|
+        @options[:deployment] = file
       end
 
-      command :upload_blobs do
-        usage  "upload blobs"
-        desc   "Upload new and updated blobs to the blobstore"
-        route  :blob_management, :upload
-      end
+      @args = @option_parser.order!(@args)
+    end
 
-      command :sync_blobs do
-        usage "sync blobs"
-        desc  "Sync blob with the blobstore"
-        route :blob_management, :sync
-      end
+    # Discover and load CLI plugins from all available gems
+    # @return [void]
+    def load_plugins
+      plugins_glob = "bosh/cli/commands/*.rb"
 
-      command :blobs_status do
-        usage "blobs"
-        desc  "Print current blobs status"
-        route :blob_management, :status
+      unless Gem.respond_to?(:find_files)
+        say("Cannot load plugins, ".yellow +
+            "please run `gem update --system' to ".yellow +
+            "update your RubyGems".yellow)
+        return
       end
 
-      def define_plugin_commands
-        plugins_glob = "bosh/cli/commands/*.rb"
-
-        unless Gem.respond_to?(:find_files)
-          say("Cannot load plugins, ".yellow +
-              "please run `gem update --system' to ".yellow +
-              "update your RubyGems".yellow)
-          return
-        end
-
-        plugins = begin
-          Gem.find_files(plugins_glob, true)
-        rescue ArgumentError
-          # Handling rubygems compatibility issue
-          Gem.find_files(plugins_glob)
-        end
-
-        plugins.each do |file|
-          class_name = File.basename(file, ".rb").capitalize
-
-          next if Bosh::Cli::Command.const_defined?(class_name)
-
-          load file
-
-          plugin = Bosh::Cli::Command.const_get(class_name)
-
-          plugin.commands.each do |name, block|
-            command(name, &block)
-          end
-
-          @plugins ||= {}
-          @plugins[class_name] = plugin
-        end
+      plugins = begin
+        Gem.find_files(plugins_glob, true)
+      rescue ArgumentError
+        # Handling rubygems compatibility issue
+        Gem.find_files(plugins_glob)
       end
 
-    end
-
-    def parse_options!
-      opts_parser = OptionParser.new do |opts|
-        opts.on("-c", "--config FILE") { |file| @options[:config] = file }
-        opts.on("--cache-dir DIR") { |dir|  @options[:cache_dir] = dir }
-        opts.on("--verbose") { @options[:verbose] = true }
-        opts.on("--no-color") { @options[:colorize] = false }
-        opts.on("-q", "--quiet") { @options[:quiet] = true }
-        opts.on("-s", "--skip-director-checks") do
-          @options[:director_checks] = false
+      plugins.each do |plugin|
+        n_commands = Config.commands.size
+        gem_dir = Pathname.new(Gem.dir)
+        plugin_name = Pathname.new(plugin).relative_path_from(gem_dir)
+        begin
+          require plugin
+        rescue Exception => e
+          say("Failed to load plugin #{plugin_name}: #{e.message}".red)
         end
-        opts.on("-n", "--non-interactive") do
-          @options[:non_interactive] = true
-          @options[:colorize] = false
+        if Config.commands.size == n_commands
+          say(("File #{plugin_name} has been loaded as plugin but it didn't " +
+              "contain any commands.\nMake sure this plugin is updated to be " +
+              "compatible with BOSH CLI 1.0.").columnize(80).yellow)
         end
-        opts.on("-d", "--debug") { @options[:debug] = true }
-        opts.on("--target URL") { |target| @options[:target] = target }
-        opts.on("--user USER") { |user| @options[:username] = user }
-        opts.on("--password PASSWORD") { |pass| @options[:password] = pass }
-        opts.on("--deployment FILE") { |file| @options[:deployment] = file }
-        opts.on("-v", "--version") { dispatch(find_command(:version)) }
       end
-
-      @args = opts_parser.order!(@args)
     end
 
     def build_parse_tree
       @parse_tree = ParseTreeNode.new
 
-      COMMANDS.each_pair do |id, command|
+      Config.commands.each_value do |command|
         p = @parse_tree
         n_kw = command.keywords.size
 
-        keywords = command.keywords.each_with_index do |kw, i|
+        command.keywords.each_with_index do |kw, i|
           p[kw] ||= ParseTreeNode.new
           p = p[kw]
           p.command = command if i == n_kw - 1
@@ -675,81 +194,17 @@ module Bosh::Cli
     end
 
     def add_shortcuts
-      { "st" => "status",
+      {
+        "st" => "status",
         "props" => "properties",
-        "cck" => "cloudcheck" }.each do |short, long|
+        "cck" => "cloudcheck"
+      }.each do |short, long|
         @parse_tree[short] = @parse_tree[long]
       end
     end
 
-    def basic_usage
-      <<-OUT.gsub(/^\s{10}/, "")
-          usage: bosh [--verbose] [--config|-c <FILE>] [--cache-dir <DIR]
-                      [--force] [--no-color] [--skip-director-checks] [--quiet]
-                      [--non-interactive]
-                      command [<args>]
-      OUT
-    end
-
-    def command_usage(cmd, margin = nil)
-      command = cmd.is_a?(Symbol) ? find_command(cmd) : cmd
-      usage = command.usage
-
-      margin ||= 2
-      usage_width = 25
-      desc_width = 43
-      option_width = 10
-
-      output = " " * margin
-      output << usage.ljust(usage_width) + " "
-      char_count = usage.size > usage_width ? 100 : 0
-
-      command.description.to_s.split(/\s+/).each do |word|
-        if char_count + word.size + 1 > desc_width # +1 accounts for space
-          char_count = 0
-          output << "\n" + " " * (margin + usage_width + 1)
-        end
-        char_count += word.size
-        output << word << " "
-      end
-
-      command.options.each do |name, value|
-        output << "\n" + " " * (margin + usage_width + 1)
-        output << name.ljust(option_width) + " "
-        # Long option name eats the whole line,
-        # short one gives space to description
-        char_count = name.size > option_width ? 100 : 0
-
-        value.to_s.split(/\s+/).each do |word|
-          if char_count + word.size + 1 > desc_width - option_width
-            char_count = 0
-            output << "\n" + " " * (margin + usage_width + option_width + 2)
-          end
-          char_count += word.size
-          output << word << " "
-        end
-      end
-
-      output
-    end
-
-    def help_message
-      template = File.join(File.dirname(__FILE__),
-                           "templates", "help_message.erb")
-      ERB.new(File.read(template), 4).result(binding.taint)
-    end
-
-    def plugin_help_message
-      help = ['']
-
-      @plugins.each do |class_name, plugin|
-        help << class_name
-        plugin.commands.keys.each do |name|
-          help << command_usage(name)
-        end
-      end
-
-      help.join("\n")
+    def usage
+      @option_parser.to_s
     end
 
     def search_parse_tree(node)
@@ -770,13 +225,12 @@ module Bosh::Cli
       # Tries to find best match among aliases (possibly multiple words),
       # then unwinds it onto the remaining args and searches parse tree again.
       # Not the most effective algorithm but does the job.
-      config = Bosh::Cli::Config.new(
-          @options[:config] || Bosh::Cli::DEFAULT_CONFIG_PATH)
+      config = Bosh::Cli::Config.new(@options[:config])
       candidate = []
       best_match = nil
       save_args = @args.dup
 
-      while arg = @args.shift
+      while (arg = @args.shift)
         candidate << arg
         resolved = config.resolve_alias(:cli, candidate.join(" "))
         if best_match && resolved.nil?
@@ -791,41 +245,11 @@ module Bosh::Cli
         return
       end
 
-      best_match.split(/\s+/).reverse.each do |arg|
-        @args.unshift(arg)
+      best_match.split(/\s+/).reverse.each do |keyword|
+        @args.unshift(keyword)
       end
 
       search_parse_tree(@parse_tree)
     end
-
-    def command_suggestions(args)
-      non_keywords = args - ALL_KEYWORDS
-
-      COMMANDS.values.select do |cmd|
-        (args & cmd.keywords).size > 0 && args - cmd.keywords == non_keywords
-      end
-    end
-
-    def unknown_command(cmd)
-      say("Command `#{cmd}' not found.")
-      say("Please use `bosh help' to get the list of bosh commands.")
-    end
-
-    def save_exception(e)
-      say("BOSH CLI Error: #{e.message}".red)
-      begin
-        errfile = File.expand_path("~/.bosh_error")
-        File.open(errfile, "w") do |f|
-          f.write(e.message)
-          f.write("\n")
-          f.write(e.backtrace.join("\n"))
-        end
-        say("Error information saved in #{errfile}")
-      rescue => e
-        say("Error information couldn't be saved: #{e.message}")
-      end
-    end
-
   end
-
 end