bosh_cli 0.18 → 0.19

data/bin/bosh

@@ -11,7 +11,10 @@ end
 $:.unshift(File.expand_path("../../lib", __FILE__))
 require "cli"
 
-trap("INT") { puts "\nExiting..."; exit(1) }
-
-Thread.abort_on_exception = true
-Bosh::Cli::Runner.run(ARGV.dup)
+begin
+  Thread.abort_on_exception = true
+  Bosh::Cli::Runner.run(ARGV.dup)
+rescue Interrupt
+  puts "\nExiting..."
+  exit(1)
+end

data/lib/cli.rb

@@ -55,8 +55,10 @@ require "cli/packaging_helper"
 require "cli/package_builder"
 require "cli/job_builder"
 require "cli/changeset_helper"
+require "cli/task_tracker"
 require "cli/task_log_renderer"
 require "cli/event_log_renderer"
+require "cli/null_renderer"
 require "cli/deployment_manifest_compiler"
 
 require "cli/release"

data/lib/cli/commands/base.rb

@@ -13,9 +13,8 @@ module Bosh::Cli
         @options = options.dup
         @work_dir = Dir.pwd
         config_file = @options[:config] || Bosh::Cli::DEFAULT_CONFIG_PATH
-        cache_dir = @options[:cache_dir] || Bosh::Cli::DEFAULT_CACHE_DIR
         @config = Config.new(config_file)
-        @cache = Cache.new(cache_dir)
+        @cache = Config.cache
       end
 
       class << self
@@ -107,22 +106,6 @@ module Bosh::Cli
         ret + " %s" % target_version if ret
       end
 
-      ##
-      # Returns whether there is currently a task running.  A wrapper for the
-      # director.rb method.
-      #
-      # @return [Boolean] Whether there is a task currently running.
-      def task_running?
-        director.has_current?
-      end
-
-      ##
-      # Cancels the task currently running.  A wrapper for the director.rb
-      # method.
-      def cancel_current_task
-        director.cancel_current
-      end
-
       protected
 
       def auth_required

data/lib/cli/commands/biff.rb

@@ -52,12 +52,8 @@ module Bosh::Cli::Command
     # @param [String] str1 The first string to diff.
     # @param [String] str2 The string to diff against.
     def print_string_diff(str1, str2)
-      File.open(@temp_file_path_1, "w") { |f|
-        f.write(str1)
-      }
-      File.open(@temp_file_path_2, "w") { |f|
-        f.write(str2)
-      }
+      File.open(@temp_file_path_1, "w") { |f| f.write(str1) }
+      File.open(@temp_file_path_2, "w") { |f| f.write(str2) }
 
       @diff_works = true
       cmd = "#{DIFF_COMMAND} #{@temp_file_path_1} #{@temp_file_path_2} 2>&1"
@@ -123,7 +119,7 @@ module Bosh::Cli::Command
               found = true
             end
           end
-        elsif obj[path_part]
+        elsif !obj[path_part].nil?
           obj = obj[path_part]
           found = true
         end

data/lib/cli/commands/cloudcheck.rb

@@ -31,6 +31,7 @@ module Bosh::Cli::Command
       status, body = director.perform_cloud_scan(deployment_name)
       scan_failed(status, body) if status != :done
 
+      nl
       say("Scan is complete, checking if any problems found...")
       @problems = director.list_problems(deployment_name)
 

data/lib/cli/commands/deployment.rb

@@ -38,12 +38,16 @@ module Bosh::Cli::Command
         old_director_uuid = nil
       end
 
-      if old_director_uuid != manifest["director_uuid"]
-        new_target_url = config.resolve_alias(:target,
-                                              manifest["director_uuid"])
+      new_director_uuid = manifest["director_uuid"]
+
+      if old_director_uuid != new_director_uuid
+        new_target_url = config.resolve_alias(:target, new_director_uuid)
+
         if new_target_url.blank?
-          err("Cannot find director url for " +
-              "UUID '#{manifest["director_uuid"]}'")
+          err("This manifest references director with UUID " +
+                "#{new_director_uuid}.\n" +
+                "You've never targeted it before.\n" +
+                "Please find your director IP or hostname and target it first.")
         end
 
         new_director = Bosh::Cli::Director.new(new_target_url,
@@ -54,7 +58,7 @@ module Bosh::Cli::Command
         config.target_name = status["name"]
         config.target_version = status["version"]
         config.target_uuid = status["uuid"]
-        say("#{"WARNING!".red} Your target has been" +
+        say("#{"WARNING!".red} Your target has been " +
             "changed to `#{target.red}'!")
       end
 

data/lib/cli/commands/job_rename.rb

@@ -0,0 +1,116 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli::Command
+  class JobRename < Base
+    include Bosh::Cli::DeploymentHelper
+
+    def rename(*args)
+      auth_required
+      manifest_yaml = prepare_deployment_manifest(:yaml => true)
+      manifest = YAML.load(manifest_yaml)
+
+      args = args.dup
+      force = args.delete("--force")
+      old_name = args.shift
+      new_name = args.shift
+
+      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}")
+    end
+
+    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)
+      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}"
+      end
+
+      if new_jobs.include?(old_name)
+        err "Old name #{old_name.green} 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"]}"
+      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}"
+      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}"
+      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}"
+      end
+
+      if added_jobs.first != 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}"
+      end
+
+      if renamed_jobs.first != old_name
+        err "Manifest does not rename old job #{old_name}"
+      end
+
+
+      # Final sanity check, make sure that no
+      # other properties or anything other than the names
+      # have changed. So update current manifest with new name
+      # and check that it matches with the old manifest
+      current_manifest["jobs"].each do |job|
+        if job["name"] == old_name
+          job["name"] = new_name
+          break
+        end
+      end
+
+      # 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."
+      end
+    end
+
+  end
+end

data/lib/cli/commands/stemcell.rb

@@ -114,9 +114,9 @@ module Bosh::Cli::Command
       yaml = get_public_stemcell_list
       stemcells_table = table do |t|
         t.headings = "Name", "Url"
-        yaml.each do |name, value|
-          if name != PUBLIC_STEMCELL_INDEX
-            t << [name, value["url"]]
+        yaml.keys.sort.each do |key|
+          if key != PUBLIC_STEMCELL_INDEX
+            t << [key, yaml[key]["url"]]
           end
         end
       end

data/lib/cli/commands/task.rb

@@ -4,7 +4,7 @@ module Bosh::Cli::Command
   class Task < Base
 
     # Tracks a running task or outputs the logs from an old task.  Triggered
-    # with 'bosh task <task_num>'.  Check parse_flags to see what flags can be
+    # with 'bosh task <task_num>'. Check parse_flags to see what flags can be
     # used with this.
     #
     # @param [Array] args The arguments from the command line command.
@@ -13,34 +13,60 @@ module Bosh::Cli::Command
 
       task_id, log_type, no_cache, raw_output = parse_flags(args)
 
-      err("Task id must be a positive integer") unless task_id.to_i > 0
+      track_options = {
+        :log_type => log_type,
+        :use_cache => no_cache ? false : true,
+        :raw_output => raw_output
+      }
 
-      task = Bosh::Cli::DirectorTask.new(director, task_id, log_type)
-      say("Task state: #{task.state}")
+      if task_id.to_i <= 0
+        err("Task id must be a positive integer")
+      end
 
-      cached_output = get_cached_task_output(task_id, log_type) unless no_cache
+      tracker = Bosh::Cli::TaskTracker.new(director, task_id, track_options)
+      tracker.track
+    end
 
-      if raw_output
-        renderer = Bosh::Cli::TaskLogRenderer.new
-      else
-        renderer = Bosh::Cli::TaskLogRenderer.create_for_log_type(log_type)
-        renderer.time_adjustment = director.get_time_difference
-      end
+    def list_running
+      auth_required
+      tasks = director.list_running_tasks
+      err("No running tasks") if tasks.empty?
+      show_tasks_table(tasks.sort_by { |t| t["id"].to_i * -1 })
+      say("Total tasks running now: %d" % [tasks.size])
+    end
+
+    def list_recent(count = 30)
+      auth_required
+      tasks = director.list_recent_tasks(count)
+      err("No recent tasks") if tasks.empty?
+      show_tasks_table(tasks)
+      say("Showing %d recent %s" % [tasks.size,
+                                    tasks.size == 1 ? "task" : "tasks"])
+    end
 
-      say("Task log:")
+    def cancel(task_id)
+      auth_required
+      task = Bosh::Cli::DirectorTask.new(director, task_id)
+      task.cancel
+      say("Cancelling task #{task_id}")
+    end
 
-      if cached_output
-        renderer.add_output(cached_output)
-        # renderer.finish calls render which prints the output.
-        renderer.finish(task.state)
-      else
-        # This calls renderer.finish which calls render and prints the output.
-        fetch_print_and_save_output(task, task_id, log_type, renderer)
-      end
+    private
+
+    # Parses the command line args to see what options have been specified.
+    #
+    # @param [Array] flags The args that were passed in from the command line.
+    # @return [String, String, Boolean, Boolean] The task id, the type of log
+    #     output, whether to use cache or not, whether to output the raw log.
+    def parse_flags(flags)
+      task_id = flags.shift
+      task_id = get_last_task_id if asking_for_last_task?(task_id)
 
-      nl
+      log_type = get_log_type(flags)
+      no_cache = flags.include?("--no-cache")
+      raw_output = flags.include?("--raw")
 
-      print_task_state_and_timing(task, task_id, renderer)
+      [task_id, log_type, no_cache, raw_output]
     end
 
     # Whether the bosh user has asked for the last (most recently run) task.
@@ -49,7 +75,7 @@ module Bosh::Cli::Command
     #     number as a string or it could be "last" or "latest".
     # @return [Boolean] Whether the user is asking for the most recent task.
     def asking_for_last_task?(task_id)
-      task_id.nil? || ["last", "latest"].include?(task_id)
+      task_id.nil? || %w(last latest).include?(task_id)
     end
 
     # Returns the task id of the most recently run task.
@@ -71,117 +97,13 @@ module Bosh::Cli::Command
     def get_log_type(flags)
       if flags.include?("--soap")
         "soap"
-      elsif flags.include?("--event")
-        "event"
-      else
+      elsif flags.include?("--debug")
         "debug"
+      else
+        "event"
       end
     end
 
-    # Parses the command line args to see what options have been specified.
-    #
-    # @param [Array] flags The args that were passed in from the command line.
-    # @return [String, String, Boolean, Boolean] The task id, the type of log
-    #     output, whether to use cache or not, whether to output the raw log.
-    def parse_flags(flags)
-      task_id = flags.shift
-      task_id = get_last_task_id if asking_for_last_task?(task_id)
-
-      log_type = get_log_type(flags)
-
-      no_cache = flags.include?("--no-cache")
-
-      raw_output = flags.include?("--raw")
-
-      [task_id, log_type, no_cache, raw_output]
-    end
-
-    # Grabs the log output for a task, prints it, then saves it to the cache.
-    #
-    # @param [Bosh::Cli::DirectorTask] task The director task that has all of
-    # the methods for retrieving/parsing the director's task JSON.
-    # @param [String] task_id The ID of the task to get logs on.
-    # @param [String] log_type The type of log output.
-    # @param [Bosh::Cli::TaskLogRenderer] renderer The renderer that renders the
-    #     parsed task JSON.
-    def fetch_print_and_save_output(task, task_id, log_type, renderer)
-      complete_output = ""
-
-      begin
-        state, output = task.state, task.output
-
-        if output
-          renderer.add_output(output)
-          complete_output << output
-        end
-
-        renderer.refresh
-        sleep(0.5)
-
-      end while ["queued", "processing", "cancelling"].include?(state)
-
-      final_out = task.flush_output
-
-      if final_out
-        renderer.add_output(final_out)
-        complete_output << final_out << "\n"
-      end
-
-      renderer.finish(state)
-      save_task_output(task_id, log_type, complete_output)
-    end
-
-    # Prints the task state and timing information at the end of the output.
-    #
-    # @param [Bosh::Cli::DirectorTask] task The director task that has all of
-    # the methods for retrieving/parsing the director's task JSON.
-    # @param [String] task_id The ID of the task to get logs on.
-    # @param [Bosh::Cli::TaskLogRenderer] renderer The renderer that renders the
-    #     parsed task JSON.
-    def print_task_state_and_timing(task, task_id, renderer)
-      final_state = task.state
-      color = {
-        "done" => :green,
-        "error" => :red,
-      }[final_state] || :yellow
-      status = "Task %s state is %s" %
-          [task_id.to_s.green, final_state.colorize(color)]
-
-      duration = renderer.duration
-      if final_state == "done" && duration && duration.kind_of?(Numeric)
-        status += ", started: %s, ended: %s (%s)" %
-            [renderer.started_at.to_s.green, renderer.finished_at.to_s.green,
-             format_time(duration).green]
-      end
-
-      say(status)
-    end
-
-    def list_running
-      auth_required
-      tasks = director.list_running_tasks
-      err("No running tasks") if tasks.empty?
-      show_tasks_table(tasks.sort_by { |t| t["id"].to_i * -1 })
-      say("Total tasks running now: %d" % [tasks.size])
-    end
-
-    def list_recent(count = 30)
-      auth_required
-      tasks = director.list_recent_tasks(count)
-      err("No recent tasks") if tasks.empty?
-      show_tasks_table(tasks)
-      say("Showing %d recent %s" % [tasks.size,
-                                    tasks.size == 1 ? "task" : "tasks"])
-    end
-
-    def cancel(task_id)
-      task = Bosh::Cli::DirectorTask.new(director, task_id)
-      task.cancel
-      say("Cancelling task #{task_id}")
-    end
-
-    private
-
     def show_tasks_table(tasks)
       return if tasks.empty?
       tasks_table = table do |t|
@@ -196,18 +118,5 @@ module Bosh::Cli::Command
       say(tasks_table)
       say("\n")
     end
-
-    def get_cached_task_output(task_id, log_type)
-      cache.read(task_cache_key(task_id, log_type))
-    end
-
-    def save_task_output(task_id, log_type, output)
-      cache.write(task_cache_key(task_id, log_type), output)
-    end
-
-    def task_cache_key(task_id, log_type)
-      "task/#{target}/#{task_id}/#{log_type}"
-    end
-
   end
 end