bosh_cli 0.19.6 → 1.0.rc1

data/lib/cli/commands/task.rb

@@ -3,22 +3,61 @@
 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
-    # used with this.
-    #
-    # @param [Array] args The arguments from the command line command.
-    def track(*args)
+    INCLUDE_ALL = "Include all task types (ssh, logs, vms, etc)"
+
+    # bosh task
+    usage  "task"
+    desc   "Show task status and start tracking its output"
+    option "--no-cache", "Don't cache output locally"
+    option "--event", "Track event log"
+    option "--soap", "Track CPI log"
+    option "--debug", "Track debug log"
+    option "--result", "Track result log"
+    option "--raw", "Show raw log"
+    option "--no-filter", INCLUDE_ALL
+    def track(task_id = nil)
       auth_required
+      use_filter = !options.key?(:no_filter)
+      use_cache = !options.key?(:no_cache)
+      raw_output = options[:raw]
+
+      log_type = "event"
+      n_types = 0
+      if options[:soap]
+        log_type = "soap"
+        n_types += 1
+      end
+
+      if options[:debug]
+        log_type = "debug"
+        n_types += 1
+      end
 
-      task_id, log_type, no_cache, raw_output = parse_flags(args)
+      if options[:event]
+        log_type = "event"
+        n_types += 1
+      end
+
+      if options[:result]
+        log_type = "result"
+        raw_output = true
+        n_types += 1
+      end
+
+      if n_types > 1
+        err("Cannot track more than one log type")
+      end
 
       track_options = {
         :log_type => log_type,
-        :use_cache => no_cache ? false : true,
+        :use_cache => use_cache,
         :raw_output => raw_output
       }
 
+      if task_id.nil? || %w(last latest).include?(task_id)
+        task_id = get_last_task_id(get_verbose_level(use_filter))
+      end
+
       if task_id.to_i <= 0
         err("Task id must be a positive integer")
       end
@@ -27,83 +66,55 @@ module Bosh::Cli::Command
       tracker.track
     end
 
+    # bosh tasks
+    usage "tasks"
+    desc "Show running tasks"
+    option "--no-filter", INCLUDE_ALL
     def list_running
       auth_required
-      tasks = director.list_running_tasks
+      use_filter = !options.key?(:no_filter)
+      tasks = director.list_running_tasks(get_verbose_level(use_filter))
       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
 
+    # bosh tasks recent
+    usage "tasks recent"
+    desc "Show <number> recent tasks"
+    option "--no-filter", INCLUDE_ALL
     def list_recent(count = 30)
       auth_required
-      tasks = director.list_recent_tasks(count)
+      use_filter = !options.key?(:no_filter)
+      tasks = director.list_recent_tasks(count, get_verbose_level(use_filter))
       err("No recent tasks") if tasks.empty?
       show_tasks_table(tasks)
-      say("Showing %d recent %s" % [tasks.size,
-                                    tasks.size == 1 ? "task" : "tasks"])
+      say("Showing #{tasks.size} recent #{tasks.size == 1 ? "task" : "tasks"}")
     end
 
+    # bosh cancel task
+    usage "cancel task"
+    desc "Cancel task once it reaches the next checkpoint"
     def cancel(task_id)
       auth_required
       task = Bosh::Cli::DirectorTask.new(director, task_id)
       task.cancel
-      say("Cancelling task #{task_id}")
+      say("Task #{task_id} is getting canceled")
     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)
-
-      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
-
-    # Whether the bosh user has asked for the last (most recently run) task.
-    #
-    # @param [String] task_id The task id specified by the user. Could be a
-    #     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? || %w(last latest).include?(task_id)
-    end
-
     # Returns the task id of the most recently run task.
-    #
     # @return [String] The task id of the most recently run task.
-    def get_last_task_id
-      last = director.list_recent_tasks(1)
-      if last.size == 0
+    def get_last_task_id(verbose = 1)
+      last = director.list_recent_tasks(1, verbose)
+      if last.empty?
         err("No tasks found")
       end
 
       last[0]["id"]
     end
 
-    # Returns what type of log output the user is asking for.
-    #
-    # @param [Array] flags The args that were passed in from the command line.
-    # @return [String] The type of log output the user is asking for.
-    def get_log_type(flags)
-      if flags.include?("--soap")
-        "soap"
-      elsif flags.include?("--debug")
-        "debug"
-      else
-        "event"
-      end
-    end
-
     def show_tasks_table(tasks)
       return if tasks.empty?
       tasks_table = table do |t|
@@ -118,5 +129,12 @@ module Bosh::Cli::Command
       say(tasks_table)
       say("\n")
     end
+
+    # Returns the verbose level for the given no_filter flag
+    # @param [Boolean] use_filter Is filtering performed?
+    # @return [Number] director verbose level
+    def get_verbose_level(use_filter)
+      use_filter ? 1 : 2
+    end
   end
 end

data/lib/cli/commands/user.rb

@@ -3,10 +3,13 @@
 module Bosh::Cli::Command
   class User < Base
 
+    # bosh create user
+    usage "create user"
+    desc  "Create user"
     def create(username = nil, password = nil)
       auth_required
 
-      unless options[:non_interactive]
+      if interactive?
         username = ask("Enter username: ") if username.blank?
         if password.blank?
           password = ask("Enter password: ") { |q| q.echo = "*" }
@@ -18,9 +21,9 @@ module Bosh::Cli::Command
       end
 
       if director.create_user(username, password)
-        say("User #{username} has been created")
+        say("User `#{username}' has been created".green)
       else
-        say("Error creating user")
+        err("Error creating user")
       end
     end
 

data/lib/cli/commands/vms.rb

@@ -4,22 +4,22 @@ module Bosh::Cli::Command
   class Vms < Base
     include Bosh::Cli::DeploymentHelper
 
-    def list(*args)
+    usage "vms"
+    desc  "List all VMs that in a deployment"
+    option "--full", "Return detailed VM information"
+    def list(deployment_name = nil)
       auth_required
+      show_full_stats = options[:full]
 
-      show_full_stats = !args.delete("--full").nil?
-      name = args.first
-
-      if name.nil?
+      if deployment_name.nil?
         deployment_required
         manifest = prepare_deployment_manifest
-        name = manifest["name"]
+        deployment_name = manifest["name"]
       end
 
-      say("Deployment #{name.green}")
-
-      vms = director.fetch_vm_state(name)
-      err("No VMs") if vms.size == 0
+      say("Deployment `#{deployment_name.green}'")
+      vms = director.fetch_vm_state(deployment_name)
+      err("No VMs") if vms.empty?
 
       sorted = vms.sort do |a, b|
         s = a["job_name"].to_s <=> b["job_name"].to_s
@@ -35,17 +35,19 @@ module Bosh::Cli::Command
         t.headings = headings
 
         sorted.each do |vm|
-          job = "#{vm["job_name"]}/#{vm["index"]}" if vm["job_name"]
-          row = [job, vm["job_state"],
-                 vm["resource_pool"], Array(vm["ips"]).join(", ")]
+          job = "#{vm["job_name"] || "unknown"}/#{vm["index"] || "unknown"}"
+          ips = Array(vm["ips"]).join(", ")
+
+          row = [job, vm["job_state"], vm["resource_pool"], ips]
           row += [vm["vm_cid"], vm["agent_id"]] if show_full_stats
+
           t << row
         end
       end
 
-      say("\n")
+      nl
       say(vms_table)
-      say("\n")
+      nl
       say("VMs total: %d" % vms.size)
     end
 

data/lib/cli/config.rb

@@ -5,14 +5,40 @@ module Bosh::Cli
     VALID_ID = /^[-a-z0-9_.]+$/i
 
     class << self
+      # @return [Hash<String,Bosh::Cli::CommandDefinition>] Available commands
+      attr_reader :commands
+
+      # @return [Boolean] Should CLI output be colorized?
       attr_accessor :colorize
+
+      # @return [IO] Where output goes
       attr_accessor :output
+
+      # @return [Boolean] Is CLI being used interactively?
       attr_accessor :interactive
+
+      # @return [Bosh::Cli::Cache] CLI cache (to save task logs etc.)
       attr_accessor :cache
     end
 
+    @commands = {}
+    @colorize = true
+    @output = nil
+    @interactive = false
+    @cache = nil
+
+    # Register command with BOSH CLI
+    # @param [Bosh::Cli::CommandDefinition] command
+    # @return [void]
+    def self.register_command(command)
+      if @commands.has_key?(command.usage)
+        raise CliError, "Duplicate command `#{command.usage}'"
+      end
+      @commands[command.usage] = command
+    end
+
     def initialize(filename, work_dir = Dir.pwd)
-      @filename = File.expand_path(filename)
+      @filename = File.expand_path(filename || Bosh::Cli::DEFAULT_CONFIG_PATH)
       @work_dir = work_dir
 
       unless File.exists?(@filename)

data/lib/cli/core_ext.rb

@@ -27,7 +27,7 @@ module BoshExtensions
   end
 
   def err(message)
-    raise Bosh::Cli::CliExit.new message
+    raise Bosh::Cli::CliError, message
   end
 
   def quit(message = nil)
@@ -85,6 +85,11 @@ module BoshExtensions
     file.write(yaml.gsub(" \n", "\n"))
     file.flush
   end
+
+  # @return [Fixnum]
+  def terminal_width
+    [HighLine::SystemExtensions.terminal_size[0], 120].min
+  end
 end
 
 module BoshStringExtensions
@@ -138,6 +143,27 @@ module BoshStringExtensions
     end
   end
 
+  def columnize(width = 80, left_margin = 0)
+    result = ""
+    buf = ""
+    self.split(/\s+/).each do |word|
+      if buf.size + word.size > width
+        result << buf << "\n" << " " * left_margin
+        buf = word + " "
+      else
+        buf << word << " "
+      end
+
+    end
+    result + buf
+  end
+
+  def indent(margin = 2)
+    self.split("\n").map { |line|
+      " " * margin + line
+    }.join("\n")
+  end
+
 end
 
 class Object

data/lib/cli/deployment_helper.rb

@@ -60,6 +60,7 @@ module Bosh::Cli
       end
 
       resolve_release_aliases(manifest)
+      resolve_stemcell_aliases(manifest)
 
       options[:yaml] ? YAML.dump(manifest) : manifest
     end
@@ -336,6 +337,52 @@ module Bosh::Cli
       end
     end
 
+    # @param [Hash] manifest Deployment manifest (will be modified)
+    # @return [void]
+    def resolve_stemcell_aliases(manifest)
+      return if manifest["resource_pools"].nil?
+
+      manifest["resource_pools"].each do |rp|
+        stemcell = rp["stemcell"]
+        unless stemcell.is_a?(Hash)
+          err("Invalid stemcell spec in the deployment manifest")
+        end
+        if stemcell["version"] == "latest"
+          latest_version = latest_stemcells[stemcell["name"]]
+          if latest_version.nil?
+            err("Latest version for stemcell `#{stemcell["name"]}' is unknown")
+          end
+          # Avoiding {Float,Fixnum} -> String noise in diff
+          if latest_version.to_s == latest_version.to_f.to_s
+            latest_version = latest_version.to_f
+          elsif latest_version.to_s == latest_version.to_i.to_s
+            latest_version = latest_version.to_i
+          end
+          stemcell["version"] = latest_version
+        end
+      end
+    end
+
+    # @return [Array]
+    def latest_stemcells
+      @_latest_stemcells ||= begin
+        stemcells = director.list_stemcells.inject({}) do |hash, stemcell|
+          unless stemcell.is_a?(Hash) && stemcell["name"] && stemcell["version"]
+            err("Invalid director stemcell list format")
+          end
+          hash[stemcell["name"]] ||= []
+          hash[stemcell["name"]] << stemcell["version"]
+          hash
+        end
+
+        stemcells.inject({}) do |hash, (name, versions)|
+          hash[name] = versions.sort { |v1, v2| version_cmp(v2, v1) }.first
+          hash
+        end
+      end
+    end
+
+    # @return [Array]
     def latest_releases
       @_latest_releases ||= begin
         director.list_releases.inject({}) do |hash, release|

data/lib/cli/director.rb

@@ -12,6 +12,12 @@ module Bosh
 
       attr_reader :director_uri
 
+      # @return [String]
+      attr_accessor :user
+
+      # @return [String]
+      attr_accessor :password
+
       def initialize(director_uri, user = nil, password = nil)
         if director_uri.nil? || director_uri =~ /^\s*$/
           raise DirectorMissing, "no director URI given"
@@ -78,17 +84,18 @@ module Bosh
         get_json("/deployments")
       end
 
-      def list_running_tasks
+      def list_running_tasks(verbose = 1)
         if version_less(get_version, "0.3.5")
           get_json("/tasks?state=processing")
         else
-          get_json("/tasks?state=processing,cancelling,queued")
+          get_json("/tasks?state=processing,cancelling,queued" +
+		   "&verbose=#{verbose}")
         end
       end
 
-      def list_recent_tasks(count = 30)
+      def list_recent_tasks(count = 30, verbose = 1)
         count = [count.to_i, 100].min
-        get_json("/tasks?limit=#{count}")
+        get_json("/tasks?limit=#{count}&verbose=#{verbose}")
       end
 
       def get_release(name)
@@ -123,6 +130,12 @@ module Bosh
         upload_and_track(:post, "/releases", filename, options)
       end
 
+      def rebase_release(filename, options = {})
+        options = options.dup
+        options[:content_type] = "application/x-compressed"
+        upload_and_track(:post, "/releases?rebase=true", filename, options)
+      end
+
       def delete_stemcell(name, version, options = {})
         options = options.dup
         request_and_track(:delete, "/stemcells/#{name}/#{version}", options)
@@ -192,11 +205,7 @@ module Bosh
         options[:payload] = JSON.generate(payload)
         options[:content_type] = "application/json"
 
-        status, task_id = request_and_track(:post, url, options)
-
-        # TODO: this needs to be done in command handler, not in director.rb
-        return nil if status != :done
-        JSON.parse(get_task_result_log(task_id))
+        request_and_track(:post, url, options)
       end
 
       def cleanup_ssh(deployment_name, job, user_regex, indexes, options = {})