bosh_cli 0.16

data/lib/cli/commands/task.rb

@@ -0,0 +1,213 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+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)
+      auth_required
+
+      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
+
+      task = Bosh::Cli::DirectorTask.new(director, task_id, log_type)
+      say("Task state: #{task.state}")
+
+      cached_output = get_cached_task_output(task_id, log_type) unless no_cache
+
+      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
+
+      say("Task log:")
+
+      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
+
+      nl
+
+      print_task_state_and_timing(task, task_id, renderer)
+    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? || ["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
+        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?("--event")
+        "event"
+      else
+        "debug"
+      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|
+        t.headings = "#", "State", "Timestamp", "Description", "Result"
+        tasks.map do |task|
+          t << [task["id"], task["state"], Time.at(task["timestamp"]).utc,
+                task["description"].to_s, task["result"].to_s.truncate(80)]
+        end
+      end
+
+      say("\n")
+      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

data/lib/cli/commands/user.rb

@@ -0,0 +1,28 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli::Command
+  class User < Base
+
+    def create(username = nil, password = nil)
+      auth_required
+
+      unless options[:non_interactive]
+        username = ask("Enter username: ") if username.blank?
+        if password.blank?
+          password = ask("Enter password: ") { |q| q.echo = "*" }
+        end
+      end
+
+      if username.blank? || password.blank?
+        err("Please enter username and password")
+      end
+
+      if director.create_user(username, password)
+        say("User #{username} has been created")
+      else
+        say("Error creating user")
+      end
+    end
+
+  end
+end

data/lib/cli/commands/vms.rb

@@ -0,0 +1,53 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli::Command
+  class Vms < Base
+    include Bosh::Cli::DeploymentHelper
+
+    def list(*args)
+      auth_required
+
+      show_full_stats = !args.delete("--full").nil?
+      name = args.first
+
+      if name.nil?
+        deployment_required
+        manifest = prepare_deployment_manifest
+        name = manifest["name"]
+      end
+
+      say("Deployment `#{name.green}'")
+
+      vms = director.fetch_vm_state(name)
+      err("No VMs") if vms.size == 0
+
+      sorted = vms.sort do |a, b|
+        s = a["job_name"].to_s <=> b["job_name"].to_s
+        s = a["index"].to_i <=> b["index"].to_i if s == 0
+        s = a["resource_pool"].to_s <=> b["resource_pool"].to_s if s == 0
+        s
+      end
+
+      vms_table = table do |t|
+        headings = ["Job/index", "State", "Resource Pool", "IPs"]
+        headings += ["Agent ID", "CID"] if show_full_stats
+
+        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(", ")]
+          row += [vm["vm_cid"], vm["agent_id"]] if show_full_stats
+          t << row
+        end
+      end
+
+      say("\n")
+      say(vms_table)
+      say("\n")
+      say("VMs total: %d" % vms.size)
+    end
+
+  end
+end

data/lib/cli/config.rb

@@ -0,0 +1,154 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli
+  class Config
+    VALID_ID = /^[-a-z0-9_.]+$/i
+
+    class << self
+      attr_accessor :colorize
+      attr_accessor :output
+      attr_accessor :interactive
+    end
+
+    def initialize(filename, work_dir = Dir.pwd)
+      @filename = File.expand_path(filename)
+      @work_dir = work_dir
+
+      unless File.exists?(@filename)
+        File.open(@filename, "w") { |f| YAML.dump({}, f) }
+        File.chmod(0600, @filename)
+      end
+
+      @config_file = load_yaml_file(@filename, nil)
+
+      unless @config_file.is_a?(Hash)
+        @config_file = { } # Just ignore it if it's malformed
+      end
+
+    rescue SystemCallError => e
+      raise ConfigError, "Cannot read config file: #{e.message}"
+    end
+
+    def auth
+      if @config_file.has_key?("auth") && @config_file["auth"].is_a?(Hash)
+        @config_file["auth"][target]
+      else
+        nil
+      end
+    end
+
+    def set_credentials(target, username, password)
+      @config_file["auth"] ||= { }
+      @config_file["auth"][target] = { "username" => username,
+                                       "password" => password }
+    end
+
+    def set_alias(category, alias_name, value)
+      @config_file["aliases"] ||= { }
+      @config_file["aliases"][category.to_s] ||= { }
+      @config_file["aliases"][category.to_s][alias_name] = value
+    end
+
+    def resolve_alias(category, alias_name)
+      category = category.to_s
+
+      if @config_file.has_key?("aliases") &&
+          @config_file["aliases"].is_a?(Hash) &&
+          @config_file["aliases"].has_key?(category) &&
+          @config_file["aliases"][category].is_a?(Hash) &&
+          !@config_file["aliases"][category][alias_name].blank?
+        @config_file["aliases"][category][alias_name].to_s
+      else
+        nil
+      end
+    end
+
+    def username
+      auth ? auth["username"] : nil
+    end
+
+    def password
+      auth ? auth["password"] : nil
+    end
+
+    # Deployment used to be a string that was only stored for your
+    # current target.  As soon as you switched targets, the deployment
+    # was erased. If the user has the old config we convert it to the
+    # new config.
+    #
+    # @return [Boolean] Whether config is using the old deployment format.
+    def is_old_deployment_config?
+      @config_file["deployment"].is_a?(String)
+    end
+
+    # Read the deployment configuration.  Return the deployment for the
+    # current target.
+    #
+    # @return [String?] The deployment path for the current target.
+    def deployment
+      return nil if target.nil?
+      if @config_file.has_key?("deployment")
+        if is_old_deployment_config?
+          set_deployment(@config_file["deployment"])
+          save
+        end
+        if @config_file["deployment"].is_a?(Hash)
+          return @config_file["deployment"][target]
+        end
+      end
+    end
+
+    # Sets the deployment file for the current target. If the deployment is
+    # the old deployment configuration, it will turn it into the format.
+    #
+    # @raise [MissingTarget] If there is no target set.
+    # @param [String] deployment_file_path The string path to the
+    #     deployment file.
+    def set_deployment(deployment_file_path)
+      raise MissingTarget, "Must have a target set." if target.nil?
+      @config_file["deployment"] = { } if is_old_deployment_config?
+      @config_file["deployment"] ||= { }
+      @config_file["deployment"][target] = deployment_file_path
+    end
+
+    [:target, :target_name, :target_version, :release,
+     :target_uuid, :status_timeout].each do |attr|
+      define_method attr do
+        read(attr, false)
+      end
+
+      define_method "#{attr}=" do |value|
+        write_global(attr, value)
+      end
+    end
+
+    def read(attr, try_local_first = true)
+      attr = attr.to_s
+      if try_local_first && @config_file[@work_dir].is_a?(Hash) &&
+          @config_file[@work_dir].has_key?(attr)
+        @config_file[@work_dir][attr]
+      else
+        @config_file[attr]
+      end
+    end
+
+    def write(attr, value)
+      @config_file[@work_dir] ||= {}
+      @config_file[@work_dir][attr.to_s] = value
+    end
+
+    def write_global(attr, value)
+      @config_file[attr.to_s] = value
+    end
+
+    def save
+      File.open(@filename, "w") do |f|
+        YAML.dump(@config_file, f)
+      end
+
+    rescue SystemCallError => e
+      raise ConfigError, e.message
+    end
+
+  end
+end