bosh_cli 1.0.3 → 1.5.0.pre.1113

data/lib/cli/commands/help.rb

@@ -78,6 +78,8 @@ module Bosh::Cli::Command
         end
       end
 
+      err("No help found for command `#{keywords.join(' ')}'. Run 'bosh help --all' to see all available BOSH commands.") if good_matches.empty?
+
       self.class.list_commands(good_matches)
     end
 
@@ -87,8 +89,7 @@ module Bosh::Cli::Command
 
       commands.each_with_index do |command, i|
         nl if i > 0
-        margin = command.usage.size + 1
-        say("#{command.usage_with_params.columnize(70, margin).green}")
+        say("#{command.usage_with_params.columnize(70).make_green}")
         say(command.desc.columnize(help_column_width).indent(help_indent))
         if command.has_options?
           say(command.options_summary.indent(help_indent))

data/lib/cli/commands/job_management.rb

@@ -1,125 +1,89 @@
 # Copyright (c) 2009-2012 VMware, Inc.
+require 'cli/job_state'
+require 'cli/vm_state'
+
+module Bosh::Cli
+  module Command
+    class JobManagement < Base
+      FORCE = 'Proceed even when there are other manifest changes'
+
+      # bosh start
+      usage 'start'
+      desc 'Start job/instance'
+      option '--force', FORCE
+      def start_job(job, index = nil)
+        change_job_state(:start, job, index)
+      end
 
-module Bosh::Cli::Command
-  class JobManagement < Base
-    include Bosh::Cli::DeploymentHelper
-
-    FORCE = "Proceed even when there are other manifest changes"
-
-    # bosh start
-    usage "start"
-    desc "Start job/instance"
-    option "--force", FORCE
-    def start_job(job, index = nil)
-      change_job_state(:start, job, index)
-    end
-
-    # bosh stop
-    usage "stop"
-    desc "Stop job/instance"
-    option "--soft", "Stop process only"
-    option "--hard", "Power off VM"
-    option "--force", FORCE
-    def stop_job(job, index = nil)
-      change_job_state(:stop, job, index)
-    end
-
-    # bosh restart
-    usage "restart"
-    desc "Restart job/instance (soft stop + start)"
-    option "--force", FORCE
-    def restart_job(job, index = nil)
-      change_job_state(:restart, job, index)
-    end
-
-    # bosh recreate
-    usage "recreate"
-    desc "Recreate job/instance (hard stop + start)"
-    option "--force", FORCE
-    def recreate_job(job, index = nil)
-      change_job_state(:recreate, job, index)
-    end
+      # bosh stop
+      usage 'stop'
+      desc 'Stop job/instance'
+      option '--soft', 'Stop process only'
+      option '--hard', 'Power off VM'
+      option '--force', FORCE
+      def stop_job(job, index = nil)
+        if hard?
+          change_job_state(:detach, job, index)
+        else
+          change_job_state(:stop, job, index)
+        end
+      end
 
-    def change_job_state(operation, job, index)
-      auth_required
-      manifest_yaml = prepare_deployment_manifest(:yaml => true)
-      manifest = YAML.load(manifest_yaml)
+      # bosh restart
+      usage 'restart'
+      desc 'Restart job/instance (soft stop + start)'
+      option '--force', FORCE
+      def restart_job(job, index = nil)
+        change_job_state(:restart, job, index)
+      end
 
-      unless [:start, :stop, :restart, :recreate].include?(operation)
-        err("Unknown operation `#{operation}': supported operations are " +
-            "`start', `stop', `restart', `recreate'")
+      # bosh recreate
+      usage 'recreate'
+      desc 'Recreate job/instance (hard stop + start)'
+      option '--force', FORCE
+      def recreate_job(job, index = nil)
+        change_job_state(:recreate, job, index)
       end
 
-      hard = options[:hard]
-      soft = options[:soft]
-      force = options[:force]
+      private
 
-      if hard && soft
-        err("Cannot handle both --hard and --soft options, please choose one")
+      def change_job_state(state, job, index = nil)
+        check_arguments(state, job)
+        index = valid_index_for(job, index)
+        vm_state = VmState.new(self, force?)
+        job_state = JobState.new(self, vm_state)
+        status, task_id, completion_desc =job_state.change(state, job, index)
+        task_report(status, task_id, completion_desc)
       end
 
-      if operation != :stop && (hard || soft)
-        err("--hard and --soft options only make sense for `stop' operation")
+      def hard?
+        options[:hard]
       end
 
-      job_desc = index ? "#{job}/#{index}" : "#{job}"
-
-      op_desc = nil
-      new_state = nil
-      completion_desc = nil
-
-      case operation
-      when :start
-        op_desc = "start #{job_desc}"
-        new_state = "started"
-        completion_desc = "#{job_desc.green} has been started"
-      when :stop
-        if hard
-          op_desc = "stop #{job_desc} and power off its VM(s)"
-          completion_desc = "#{job_desc.green} has been stopped, " +
-                            "VM(s) powered off"
-          new_state = "detached"
-        else
-          op_desc = "stop #{job_desc}"
-          completion_desc = "#{job_desc.green} has been stopped, " +
-                            "VM(s) still running"
-          new_state = "stopped"
-        end
-      when :restart
-        op_desc = "restart #{job_desc}"
-        new_state = "restart"
-        completion_desc = "#{job_desc.green} has been restarted"
-      when :recreate
-        op_desc = "recreate #{job_desc}"
-        new_state = "recreate"
-        completion_desc = "#{job_desc.green} has been recreated"
-      else
-        err("Unknown operation: `#{operation}'")
+      def soft?
+        options[:soft]
       end
 
-      say("You are about to #{op_desc.green}")
+      def force?
+        options[:force]
+      end
 
-      if interactive?
-        other_changes_present = inspect_deployment_changes(
-            manifest, :show_empty_changeset => false)
+      def check_arguments(operation, job)
+        auth_required
+        job_must_exist_in_deployment(job)
 
-        if other_changes_present && !force
-          err("Cannot perform job management when other deployment changes " +
-              "are present. Please use `--force' to override.")
+        if hard? && soft?
+          err('Cannot handle both --hard and --soft options, please choose one')
         end
-        unless confirmed?("#{op_desc.capitalize}?")
-          cancel_deployment
+
+        if !hard_and_soft_options_allowed?(operation) && (hard? || soft?)
+          err("--hard and --soft options only make sense for `stop' operation")
         end
       end
 
-      nl
-      say("Performing `#{op_desc}'...")
-
-      status, task_id = director.change_job_state(
-        manifest["name"], manifest_yaml, job, index, new_state)
-
-      task_report(status, task_id, completion_desc)
+      def hard_and_soft_options_allowed?(operation)
+        operation == :stop || operation == :detach
+      end
     end
-
   end
 end

data/lib/cli/commands/job_rename.rb

@@ -2,8 +2,6 @@
 
 module Bosh::Cli::Command
   class JobRename < Base
-    include Bosh::Cli::DeploymentHelper
-
     # bosh rename
     usage "rename job"
     desc "Renames a job. NOTE, your deployment manifest must also be " +
@@ -12,14 +10,14 @@ module Bosh::Cli::Command
     def rename(old_name, new_name)
       auth_required
       manifest_yaml = prepare_deployment_manifest(:yaml => true)
-      manifest = YAML.load(manifest_yaml)
+      manifest = Psych.load(manifest_yaml)
 
       force = options[:force]
-      say("You are about to rename `#{old_name.green}' to `#{new_name.green}'")
+      say("You are about to rename `#{old_name.make_green}' to `#{new_name.make_green}'")
 
       unless confirmed?
         nl
-        say("Job rename canceled".green)
+        say("Job rename canceled".make_green)
         exit(0)
       end
 
@@ -33,7 +31,7 @@ module Bosh::Cli::Command
 
     def sanity_check_job_rename(manifest_yaml, old_name, new_name)
       # Makes sure the new deployment manifest contains the renamed job
-      manifest = YAML.load(manifest_yaml)
+      manifest = Psych.load(manifest_yaml)
       new_jobs = manifest["jobs"].map { |job| job["name"] }
       unless new_jobs.include?(new_name)
         err("Please update your deployment manifest to include the " +
@@ -52,7 +50,7 @@ module Bosh::Cli::Command
             "`#{manifest["name"]}'")
       end
 
-      current_manifest = YAML.load(current_deployment["manifest"])
+      current_manifest = Psych.load(current_deployment["manifest"])
       jobs = current_manifest["jobs"].map { |job| job["name"] }
       unless jobs.include?(old_name)
         err("Trying to rename a non existent job `#{old_name}'")
@@ -99,7 +97,7 @@ module Bosh::Cli::Command
       end
 
       # Now the manifests should be the same
-      manifest = YAML.load(manifest_yaml)
+      manifest = Psych.load(manifest_yaml)
       if deployment_changed?(current_manifest.dup, manifest.dup)
         err("You cannot have any other changes to your manifest during " +
             "rename. Please revert the above changes and retry.")

data/lib/cli/commands/log_management.rb

@@ -2,78 +2,101 @@
 
 module Bosh::Cli::Command
   class LogManagement < Base
-    include Bosh::Cli::DeploymentHelper
-
     # bosh logs
-    usage "logs"
-    desc "Fetch job or agent logs from a BOSH-managed VM"
-    option "--agent", "fetch agent logs"
-    option "--job", "fetch job logs"
-    option "--only filter1,filter2,...", Array,
-           "only fetch logs that satisfy",
-           "given filters (defined in job spec)"
-    option "--all", "fetch all files in the job or agent log directory"
-    def fetch_logs(job, index)
-      auth_required
-      target_required
-      no_track_unsupported
+    usage 'logs'
+    desc 'Fetch job or agent logs from a BOSH-managed VM'
+    option '--agent', 'fetch agent logs'
+    option '--job', 'fetch job logs'
+    option '--only filter1,filter2,...', Array,
+           'only fetch logs that satisfy',
+           'given filters (defined in job spec)'
+    option '--all', 'fetch all files in the job or agent log directory'
+    option '--dir destination_directory', String, 'download directory'
+    def fetch_logs(job, index = nil)
+      index = valid_index_for(job, index)
+      check_arguments(index)
+
+      resource_id = fetch_log_resource_id(index, job)
+      log_file_path = log_file_destination(index, job)
+      download_logs(log_file_path, resource_id)
+    end
 
-      if index !~ /^\d+$/
-        err("Job index is expected to be a positive integer")
-      end
+    def fetch_log_resource_id(index, job)
+      resource_id = director.fetch_logs(deployment_name, job, index, log_type, filters)
+      err('Error retrieving logs') if resource_id.nil?
 
-      if options[:agent]
-        if options[:job]
-          err("You can't use --job and --agent together")
-        end
-        log_type = "agent"
-      else
-        log_type = "job"
-      end
-
-      if options[:only]
-        if options[:all]
-          err("You can't use --only and --all together")
-        end
-        filters = options[:only].join(",")
-      elsif options[:all]
-        filters = "all"
-      else
-        filters = nil
-      end
-
-      if options[:agent] && filters && filters != "all"
-        err("Custom filtering is not supported for agent logs")
-      end
+      resource_id
+    end
 
-      manifest = prepare_deployment_manifest
+    private
 
-      resource_id = director.fetch_logs(
-        manifest["name"], job, index, log_type, filters)
+    def agent_logs_wanted?
+      options[:agent]
+    end
 
-      if resource_id.nil?
-        err("Error retrieving logs")
-      end
+    def job_logs_wanted?
+      options[:job]
+    end
 
-      nl
-      say("Downloading log bundle (#{resource_id.to_s.green})...")
+    def download_logs(log_file_path, resource_id)
+      say("Downloading log bundle (#{resource_id.to_s.make_green})...")
 
       begin
-        time = Time.now.strftime("%Y-%m-%d@%H-%M-%S")
-        log_file = File.join(Dir.pwd, "#{job}.#{index}.#{time}.tgz")
-
         tmp_file = director.download_resource(resource_id)
-
-        FileUtils.mv(tmp_file, log_file)
-        say("Logs saved in `#{log_file.green}'")
+        FileUtils.mv(tmp_file, log_file_path)
+        say("Logs saved in `#{log_file_path.make_green}'")
       rescue Bosh::Cli::DirectorError => e
         err("Unable to download logs from director: #{e}")
       ensure
-        FileUtils.rm_rf(tmp_file) if File.exists?(tmp_file)
+        FileUtils.rm_rf(tmp_file) if tmp_file && File.exists?(tmp_file)
+      end
+    end
+
+    def check_arguments(index)
+      auth_required
+      no_track_unsupported
+
+      err('Job index is expected to be a positive integer') if index !~ /^\d+$/
+
+      if agent_logs_wanted? && options[:only]
+        err('Custom filtering is not supported for agent logs')
       end
+    end
+
+    def log_type
+      err("You can't use --job and --agent together") if job_logs_wanted? && agent_logs_wanted?
 
+      if agent_logs_wanted?
+        'agent'
+      else
+        'job'
+      end
     end
 
+    def filters
+      if options[:only]
+        err("You can't use --only and --all together") if options[:all]
+        filter = options[:only].join(',')
+      elsif options[:all]
+        filter = 'all'
+      else
+        filter = nil
+      end
+      filter
+    end
+
+    def log_file_destination(index, job)
+      time = Time.now.strftime('%Y-%m-%d@%H-%M-%S')
+      File.join(log_directory, "#{job}.#{index}.#{time}.tgz")
+    end
+
+    def log_directory
+      options[:dir] || Dir.pwd
+    end
+
+    def deployment_name
+      prepare_deployment_manifest['name']
+    end
   end
 end
 

data/lib/cli/commands/maintenance.rb

@@ -8,8 +8,8 @@ module Bosh::Cli::Command
     STEMCELLS_TO_KEEP = 2
 
     # bosh cleanup
-    usage "cleanup"
-    desc  "Cleanup releases and stemcells"
+    usage 'cleanup'
+    desc 'Cleanup releases and stemcells'
     def cleanup
       target_required
       auth_required
@@ -17,16 +17,16 @@ module Bosh::Cli::Command
       releases_to_keep = RELEASES_TO_KEEP
       stemcells_to_keep = STEMCELLS_TO_KEEP
 
-      release_wording = pluralize(releases_to_keep, "latest version")
-      stemcell_wording = pluralize(stemcells_to_keep, "latest version")
+      release_wording = pluralize(releases_to_keep, 'latest version')
+      stemcell_wording = pluralize(stemcells_to_keep, 'latest version')
 
       desc = <<-EOS.gsub(/^ */, "")
         Cleanup command will attempt to delete old unused
         release versions and stemcells from your currently
-        targeted director at #{target_name.green}.
+        targeted director at #{target_name.make_green}.
 
-        Only #{release_wording.green} of each release
-        and #{stemcell_wording.green} of each stemcell will be kept.
+        Only #{release_wording.make_green} of each release
+        and #{stemcell_wording.make_green} of each stemcell will be kept.
 
         Releases and stemcells that are in use will not be affected.
       EOS
@@ -35,7 +35,7 @@ module Bosh::Cli::Command
       say(desc)
       nl
 
-      err("Cleanup canceled") unless confirmed?
+      err('Cleanup canceled') unless confirmed?
 
       nl
       cleanup_stemcells(stemcells_to_keep)
@@ -43,48 +43,54 @@ module Bosh::Cli::Command
       cleanup_releases(releases_to_keep)
 
       nl
-      say("Cleanup complete".green)
+      say('Cleanup complete'.make_green)
     end
 
     private
 
     def cleanup_stemcells(n_to_keep)
       stemcells_by_name = director.list_stemcells.inject({}) do |h, stemcell|
-        h[stemcell["name"]] ||= []
-        h[stemcell["name"]] << stemcell
+        h[stemcell['name']] ||= []
+        h[stemcell['name']] << stemcell
         h
       end
 
       delete_list = []
-      say("Deleting old stemcells")
+      say('Deleting old stemcells')
 
       stemcells_by_name.each_pair do |name, stemcells|
         stemcells.sort! do |sc1, sc2|
-          version_cmp(sc1["version"], sc2["version"])
+          version_cmp(sc1['version'], sc2['version'])
         end
         delete_list += stemcells[0...(-n_to_keep)]
       end
 
       if delete_list.size > 0
         delete_list.each do |stemcell|
-          name, version = stemcell["name"], stemcell["version"]
+          name, version = stemcell['name'], stemcell['version']
           desc = "#{name}/#{version}"
           perform(desc) do
             director.delete_stemcell(name, version, :quiet => true)
           end
         end
       else
-        say("  none found".yellow)
+        say('  none found'.make_yellow)
       end
     end
 
     def cleanup_releases(n_to_keep)
       delete_list = []
-      say("Deleting old release versions")
+      say('Deleting old release versions')
 
       director.list_releases.each do |release|
-        name = release["name"]
-        versions = release["versions"].sort { |v1, v2| version_cmp(v1, v2) }
+        name = release['name']
+        versions = if release['versions']
+          release['versions']
+        else
+          release['release_versions'].map { |release_version| release_version['version'] }
+        end
+
+        versions.sort! { |v1, v2| version_cmp(v1, v2) }
 
         versions[0...(-n_to_keep)].each do |version|
           delete_list << [name, version]
@@ -100,33 +106,33 @@ module Bosh::Cli::Command
           end
         end
       else
-        say("  none found".yellow)
+        say('  none found'.make_yellow)
       end
     end
 
     def refresh(message)
-      say("\r", "")
-      say(" " * 80, "")
-      say("\r#{message}", "")
+      say("\r", '')
+      say(' ' * 80, '')
+      say("\r#{message}", '')
     end
 
     def perform(desc)
-      say("  #{desc.yellow.ljust(40)}", "")
-      say("IN PROGRESS...".yellow, "")
+      say("  #{desc.make_yellow.ljust(40)}", '')
+      say(' IN PROGRESS...'.make_yellow, '')
 
       status, task_id = yield
       responses = {
-        :done => "DELETED".green,
-        :non_trackable => "CANNOT TRACK".red,
-        :track_timeout => "TIMED OUT".red,
-        :error => "ERROR".red,
+        :done => 'DELETED'.make_green,
+        :non_trackable => 'CANNOT TRACK'.make_red,
+        :track_timeout => 'TIMED OUT'.make_red,
+        :error => 'ERROR'.make_red,
       }
 
-      refresh("  #{desc.yellow.ljust(40)}#{responses[status]}\n")
+      refresh("  #{desc.make_yellow.ljust(50)}#{responses[status]}\n")
 
       if status == :error
         result = director.get_task_result(task_id)
-        say("  #{result.to_s.red}")
+        say("  #{result.to_s.make_red}")
       end
 
       status == :done