bosh_cli 0.19.1 → 0.19.2

data/lib/cli/commands/base.rb

@@ -15,6 +15,7 @@ module Bosh::Cli
         config_file = @options[:config] || Bosh::Cli::DEFAULT_CONFIG_PATH
         @config = Config.new(config_file)
         @cache = Config.cache
+        @exit_code = 0
       end
 
       class << self
@@ -106,6 +107,42 @@ module Bosh::Cli
         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
+      def exit_code(code = nil)
+        if code
+          @exit_code = code
+        else
+          @exit_code
+        end
+      end
+
+      # Prints director task completion report. Note that event log usually
+      # contains pretty detailed error report and other UI niceties, so most
+      # of the time this could just do nothing
+      # @param [Symbol] status Task status
+      def task_report(status, success_msg = nil, error_msg = nil)
+        case status
+          when :non_trackable
+            report = "Can't track director task".red
+          when :track_timeout
+            report = "Task tracking timeout".red
+          when :error
+            report = error_msg
+          when :done
+            report = success_msg
+          else
+            report = nil
+        end
+
+        if status != :done
+          exit_code(1)
+        end
+
+        say("\n#{report}") if report
+      end
+
       protected
 
       def auth_required

data/lib/cli/commands/cloudcheck.rb

@@ -28,8 +28,12 @@ module Bosh::Cli::Command
       manifest = prepare_deployment_manifest
       deployment_name = manifest["name"]
 
-      status, body = director.perform_cloud_scan(deployment_name)
-      scan_failed(status, body) if status != :done
+      status, _ = director.perform_cloud_scan(deployment_name)
+
+      if status != :done
+        task_report(status)
+        exit(1)
+      end
 
       nl
       say("Scan is complete, checking if any problems found...")
@@ -69,36 +73,17 @@ module Bosh::Cli::Command
         hash
       end
 
-      status, body = director.apply_resolutions(deployment_name, action_map)
-      resolution_failed(status, body) if status != :done
-      say("Cloudcheck is finished".green)
-    end
-
-    private
+      status, _ = director.apply_resolutions(deployment_name, action_map)
 
-    def scan_failed(status, response)
-      responses = {
-        :non_trackable => "Unable to track cloud scan progress, " +
-            "please update your director",
-        :track_timeout => "Timed out while tracking cloud scan progress",
-        :error         => "Cloud scan error",
-        :invalid       => "Invalid cloud scan request"
-      }
+      if status != :done
+        task_report(status)
+        exit(1)
+      end
 
-      err(responses[status] || "Cloud scan failed: #{response}")
+      say("Cloudcheck is finished".green)
     end
 
-    def resolution_failed(status, response)
-      responses = {
-        :non_trackable => "Unable to track problem resolution progress, " +
-            "please update your director",
-        :track_timeout => "Timed out while tracking problem resolution progress",
-        :error         => "Problem resolution error",
-        :invalid       => "Invalid problem resolution request"
-      }
-
-      err(responses[status] || "Problem resolution failed: #{response}")
-    end
+    private
 
     def verify_problems
       err("Invalid problem list format") unless @problems.kind_of?(Enumerable)
@@ -150,7 +135,6 @@ module Bosh::Cli::Command
       nl
 
       @problems.each_with_index do |problem, index|
-        description = problem["description"]
         plan = @resolutions[problem["id"]]["plan"]
         padding = " " * ((index+1).to_s.size + 4)
         say("  #{index+1}. #{problem["description"]}")

data/lib/cli/commands/deployment.rb

@@ -85,20 +85,9 @@ module Bosh::Cli::Command
         cancel_deployment
       end
 
-      status, body = director.deploy(manifest_yaml, :recreate => recreate)
-
-      responses = {
-        :done => "Deployed #{desc}",
-        :non_trackable => "Started deployment but director at `#{target}' " +
-                           "doesn't support deployment tracking",
-        :track_timeout => "Started deployment but timed out out " +
-                          "while tracking status",
-        :error => "Started deployment but received an error " +
-                  "while tracking status",
-        :invalid => "Deployment is invalid, please fix it and deploy again"
-      }
-
-      say(responses[status] || "Cannot deploy: #{body}")
+      status, _ = director.deploy(manifest_yaml, :recreate => recreate)
+
+      task_report(status, "Deployed #{desc}")
     end
 
     def delete(name, *options)
@@ -113,19 +102,9 @@ module Bosh::Cli::Command
         return
       end
 
-      status, message = director.delete_deployment(name, :force => force)
-
-      responses = {
-        :done          => "Deleted deployment '#{name}'",
-        :non_trackable => "Deployment delete in progress but director " +
-            "at '#{target}' doesn't support task tracking",
-        :track_timeout => "Timed out out while tracking deployment " +
-            "deletion progress",
-        :error         => "Attempted to delete deployment but received " +
-            "an error while tracking status",
-      }
+      status, _ = director.delete_deployment(name, :force => force)
 
-      say(responses[status] || "Cannot delete deployment: #{message}")
+      task_report(status, "Deleted deployment `#{name}'")
     end
 
     def list
@@ -136,7 +115,7 @@ module Bosh::Cli::Command
       err("No deployments") if deployments.size == 0
 
       deployments_table = table do |t|
-        t.headings = ["Name"]
+        t.headings = %w(Name)
         deployments.each do |r|
           t << [r["name"]]
         end

data/lib/cli/commands/job_management.rb

@@ -45,9 +45,12 @@ module Bosh::Cli::Command
 
       job = args.shift
       index = args.shift
-      deployment_desc = "`#{deployment.green}' to `#{target_name.green}'"
       job_desc = index ? "#{job}(#{index})" : "#{job}"
 
+      op_desc = nil
+      new_state = nil
+      completion_desc = nil
+
       case operation
       when :start
         op_desc = "start #{job_desc}"
@@ -73,6 +76,8 @@ module Bosh::Cli::Command
         op_desc = "recreate #{job_desc}"
         new_state = "recreate"
         completion_desc = "#{job_desc.green} has been recreated"
+      else
+        err("Unknown operation: `#{operation}'")
       end
 
       say("You are about to #{op_desc.green}")
@@ -95,22 +100,12 @@ module Bosh::Cli::Command
 
       say("Performing `#{op_desc}'...")
 
-      status, body = director.change_job_state(manifest["name"],
-                                               manifest_yaml,
-                                               job, index, new_state)
-
-      responses = {
-        :done => completion_desc,
-        :non_trackable => "Started deployment but director at '#{target}' " +
-                          "doesn't support deployment tracking",
-        :track_timeout => "Started deployment but timed out out "+
-                          "while tracking status",
-        :error => "Started deployment but received an error " +
-                  "while tracking status",
-        :invalid => "Deployment is invalid, please fix it and deploy again"
-      }
-
-      say(responses[status] || "Cannot deploy: #{body}")
+      status, _ =
+        director.change_job_state(manifest["name"],
+                                  manifest_yaml,
+                                  job, index, new_state)
+
+      task_report(status, completion_desc)
     end
 
   end

data/lib/cli/commands/job_rename.rb

@@ -14,25 +14,20 @@ module Bosh::Cli::Command
       old_name = args.shift
       new_name = args.shift
 
+      say("You are about to rename #{old_name.green} to #{new_name.green}")
+
+      unless confirmed?
+        nl
+        say("Job rename canceled".green)
+        return
+      end
+
       sanity_check_job_rename(manifest_yaml, old_name, new_name)
 
-      say("You are about to rename #{old_name.green} to " +
-          "#{new_name.green} #{force}")
-
-      status, body = director.rename_job(manifest["name"], manifest_yaml,
-                                         old_name, new_name, force)
-      responses = {
-        :done => "Rename successful",
-        :non_trackable => "Started deployment but director at '#{target}' " +
-                          "doesn't support deployment tracking",
-        :track_timeout => "Started deployment but timed out out "+
-                          "while tracking status",
-        :error => "Started deployment but received an error " +
-                  "while tracking status",
-        :invalid => "Deployment is invalid, please fix it and deploy again"
-      }
-
-      say(responses[status] || "Cannot deploy: #{body}")
+      status, _ = director.rename_job(manifest["name"], manifest_yaml,
+                                      old_name, new_name, force)
+
+      task_report(status, "Rename successful")
     end
 
     def sanity_check_job_rename(manifest_yaml, old_name, new_name)
@@ -41,55 +36,55 @@ module Bosh::Cli::Command
       manifest = YAML.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 " +
-            "new job name #{new_name.green}"
+        err("Please update your deployment manifest to include the " +
+            "new job name `#{new_name}'")
       end
 
       if new_jobs.include?(old_name)
-        err "Old name #{old_name.green} is still being used in the " +
-            "deployment file"
+        err("Old name `#{old_name}' is still being used in the " +
+            "deployment file")
       end
 
       # Make sure that the old deployment manifest contains the old job
       current_deployment = director.get_deployment(manifest["name"])
       if current_deployment["manifest"].nil?
-        err "Director could not find manifest for deployment " +
-            "#{manifest["name"]}"
+        err("Director could not find manifest for deployment " +
+            "`#{manifest["name"]}'")
       end
 
       current_manifest = YAML.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}"
+        err("Trying to rename a non existent job `#{old_name}'")
       end
 
       # Technically we could allow this
       if jobs.include?(new_name)
-        err "Trying to reuse an existing job name #{new_name} " +
-            "to rename job #{old_name}"
+        err("Trying to reuse an existing job name `#{new_name}' " +
+            "to rename job `#{old_name}'")
       end
 
       # Make sure that only one job has been renamed
       added_jobs = new_jobs - jobs
 
       if added_jobs.size > 1
-        err "Cannot rename more than one job, you are trying to " +
-            "add #{added_jobs.inspect}"
+        err("Cannot rename more than one job, you are trying to " +
+            "add #{added_jobs.inspect}")
       end
 
       if added_jobs.first != new_name
-        err "Manifest does not include new job #{new_name}"
+        err("Manifest does not include new job `#{new_name}'")
       end
 
       renamed_jobs = jobs - new_jobs
 
       if renamed_jobs.size > 1
-        err "Cannot rename more than one job, you have changes to " +
-            "#{renamed_jobs}"
+        err("Cannot rename more than one job, you have changes to " +
+            "#{renamed_jobs}")
       end
 
       if renamed_jobs.first != old_name
-        err "Manifest does not rename old job #{old_name}"
+        err("Manifest does not rename old job `#{old_name}'")
       end
 
 
@@ -107,8 +102,8 @@ module Bosh::Cli::Command
       # Now the manifests should be the same
       manifest = YAML.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."
+        err("You cannot have any other changes to your manifest during " +
+            "rename. Please revert the above changes and retry.")
       end
     end
 

data/lib/cli/commands/log_management.rb

@@ -11,6 +11,7 @@ module Bosh::Cli::Command
       job = args.shift
       index = args.shift
       filters = nil
+      log_type = nil
 
       for_job = args.delete("--job")
       for_agent = args.delete("--agent")

data/lib/cli/commands/maintenance.rb

@@ -120,8 +120,8 @@ module Bosh::Cli::Command
       refresh("  #{desc.yellow.ljust(40)}#{responses[status]}\n")
 
       if status == :error
-        task = director.get_task(task_id)
-        say("  #{task["result"].red}")
+        result = director.get_task_result(task_id)
+        say("  #{result.to_s.red}")
       end
 
       status == :done

data/lib/cli/commands/misc.rb

@@ -53,16 +53,16 @@ module Bosh::Cli::Command
             File.join(work_dir, "releases")).latest_version
 
         say("Dev name:      %s" % [dev_name ? dev_name.green : "not set".red])
-        say("Dev version:   %s" % [dev_version && dev_version > 0 ?
-                                       dev_version.to_s.green : "
-                                       no versions yet".red])
+        say("Dev version:   %s" % [dev_version ?
+                                     dev_version.to_s.green :
+                                     "no versions yet".red])
         say("\n")
         say("Final name:    %s" % [final_name ?
                                        final_name.green :
                                        "not set".red])
-        say("Final version: %s" % [final_version && final_version > 0 ?
-                                       final_version.to_s.green :
-                                       "no versions yet".red])
+        say("Final version: %s" % [final_version ?
+                                     final_version.to_s.green :
+                                     "no versions yet".red])
 
         say("\n")
         say("Packages")

data/lib/cli/commands/release.rb

@@ -110,13 +110,16 @@ module Bosh::Cli::Command
     def upload_manifest(manifest_path)
       manifest = load_yaml_file(manifest_path)
       remote_release = get_remote_release(manifest["name"]) rescue nil
+      remote_jobs = remote_release["jobs"] if remote_release
+      remote_packages_sha1 = match_remote_packages(File.read(manifest_path))
       blobstore = release.blobstore
       tmpdir = Dir.mktmpdir
 
       at_exit { FileUtils.rm_rf(tmpdir) }
 
-      compiler = Bosh::Cli::ReleaseCompiler.new(manifest_path,
-                                                blobstore, remote_release)
+      compiler = Bosh::Cli::ReleaseCompiler.new(manifest_path, blobstore,
+                                                remote_jobs,
+                                                remote_packages_sha1)
       need_repack = true
 
       unless compiler.exists?
@@ -141,14 +144,19 @@ module Bosh::Cli::Command
       end
 
       begin
-        remote_release = get_remote_release(tarball.release_name)
-        if remote_release["versions"].include?(tarball.version)
-          err("This release version has already been uploaded")
+        remote_release = get_remote_release(tarball.release_name) rescue nil
+        if remote_release
+          if remote_release["versions"].include?(tarball.version)
+            err("This release version has already been uploaded")
+          end
+          remote_jobs = remote_release["jobs"]
         end
 
         if repack
+          remote_packages_sha1 = match_remote_packages(tarball.manifest)
+
           say("Checking if can repack release for faster upload...")
-          repacked_path = tarball.repack(remote_release)
+          repacked_path = tarball.repack(remote_jobs, remote_packages_sha1)
           if repacked_path.nil?
             say("Uploading the whole release".green)
           else
@@ -163,18 +171,9 @@ module Bosh::Cli::Command
       end
 
       say("\nUploading release...\n")
-      status, message = director.upload_release(tarball_path)
-
-      responses = {
-        :done => "Release uploaded and updated",
-        :non_trackable => "Uploaded release but director at #{target} " +
-                           "doesn't support update tracking",
-        :track_timeout => "Uploaded release but timed out out " +
-                           "while tracking status",
-        :error => "Uploaded release but received an error while tracking status"
-      }
-
-      say(responses[status] || "Cannot upload release: #{message}")
+      status, _ = director.upload_release(tarball_path)
+
+      task_report(status, "Release uploaded")
     end
 
     def create(*options)
@@ -200,10 +199,10 @@ module Bosh::Cli::Command
     def create_from_spec(*options)
       flags = options.inject({}) { |h, option| h[option] = true; h }
 
-      final         = flags.delete("--final")
-      force         = flags.delete("--force")
+      final = flags.delete("--final")
+      force = flags.delete("--force")
       manifest_only = !flags.delete("--with-tarball")
-      dry_run       = flags.delete("--dry-run")
+      dry_run = flags.delete("--dry-run")
 
       if final && !release.has_blobstore_secret?
         say("Can't create final release without blobstore secret".red)
@@ -405,20 +404,9 @@ module Bosh::Cli::Command
       end
 
       if confirmed?
-        status, body = director.delete_release(name, :force => force,
+        status, _ = director.delete_release(name, :force => force,
                                                :version => version)
-        responses = {
-          :done => "Deleted #{desc}",
-          :non_trackable => "Started deleting release but director " +
-                            "at '#{target}' doesn't support " +
-                            "deployment tracking",
-          :track_timeout => "Started deleting release but timed out out " +
-                            "while tracking status",
-          :error => "Started deleting release but received an error " +
-                    "while tracking status",
-        }
-
-        say(responses[status] || "Cannot delete release: #{body}")
+        task_report(status, "Deleted #{desc}")
       else
         say("Canceled deleting release".green)
       end
@@ -486,5 +474,16 @@ module Bosh::Cli::Command
 
       release
     end
+
+    def match_remote_packages(manifest_yaml)
+      # Catch exceptions to be friendly to old directors
+      result = director.match_packages(manifest_yaml) rescue []
+
+      unless result.is_a?(Array)
+        say("Cannot find existing packages info " +
+            "in the director response, maybe old director?")
+      end
+      result
+    end
   end
 end