bosh_cli 0.16

data/lib/cli/commands/deployment.rb

@@ -0,0 +1,147 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli::Command
+  class Deployment < Base
+    include Bosh::Cli::DeploymentHelper
+
+    def show_current
+      say(deployment ?
+              "Current deployment is '#{deployment.green}'" :
+              "Deployment not set")
+    end
+
+    def set_current(name)
+      manifest_filename = find_deployment(name)
+
+      unless File.exists?(manifest_filename)
+        err("Missing manifest for #{name} (tried '#{manifest_filename}')")
+      end
+
+      manifest = load_yaml_file(manifest_filename)
+
+      unless manifest.is_a?(Hash)
+        err("Invalid manifest format")
+      end
+
+      unless manifest["target"].blank?
+        err(manifest_target_upgrade_notice)
+      end
+
+      if manifest["director_uuid"].blank?
+        err("Director UUID is not defined in deployment manifest")
+      end
+
+      if target
+        old_director = Bosh::Cli::Director.new(target, username, password)
+        old_director_uuid = old_director.get_status["uuid"] rescue nil
+      else
+        old_director_uuid = nil
+      end
+
+      if old_director_uuid != manifest["director_uuid"]
+        new_target_url = config.resolve_alias(:target,
+                                              manifest["director_uuid"])
+        if new_target_url.blank?
+          err("Cannot find director url for " +
+              "UUID '#{manifest["director_uuid"]}'")
+        end
+
+        new_director = Bosh::Cli::Director.new(new_target_url,
+                                               username, password)
+        status = new_director.get_status
+
+        config.target = new_target_url
+        config.target_name = status["name"]
+        config.target_version = status["version"]
+        config.target_uuid = status["uuid"]
+        say("#{"WARNING!".red} Your target has been" +
+            "changed to `#{target.red}'!")
+      end
+
+      say("Deployment set to '#{manifest_filename.green}'")
+      config.set_deployment(manifest_filename)
+      config.save
+    end
+
+    def perform(*options)
+      auth_required
+      recreate = options.include?("--recreate")
+
+      manifest_yaml = prepare_deployment_manifest(:yaml => true,
+                                                  :resolve_properties => true)
+
+      if interactive?
+        inspect_deployment_changes(YAML.load(manifest_yaml))
+        say("Please review all changes carefully".yellow)
+      end
+
+      desc = "`#{File.basename(deployment).green}' to `#{target_name.green}'"
+
+      unless confirmed?("Deploying #{desc}")
+        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}")
+    end
+
+    def delete(name, *options)
+      auth_required
+      force = options.include?("--force")
+
+      say("\nYou are going to delete deployment `#{name}'.\n\n")
+      say("THIS IS A VERY DESTRUCTIVE OPERATION AND IT CANNOT BE UNDONE!\n".red)
+
+      unless confirmed?
+        say("Canceled deleting deployment".green)
+        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",
+      }
+
+      say(responses[status] || "Cannot delete deployment: #{message}")
+    end
+
+    def list
+      auth_required
+
+      deployments = director.list_deployments
+
+      err("No deployments") if deployments.size == 0
+
+      deployments_table = table do |t|
+        t.headings = ["Name"]
+        deployments.each do |r|
+          t << [r["name"]]
+        end
+      end
+
+      say("\n")
+      say(deployments_table)
+      say("\n")
+      say("Deployments total: %d" % deployments.size)
+    end
+  end
+end

data/lib/cli/commands/job.rb

@@ -0,0 +1,42 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli::Command
+  class Job < Base
+
+    def generate(name)
+      check_if_release_dir
+
+      unless name.bosh_valid_id?
+        err("`#{name}' is not a vaild BOSH id")
+      end
+
+      job_dir = File.join("jobs", name)
+
+      if File.exists?(job_dir)
+        err("Job `#{name}' already exists, please pick another name")
+      end
+
+      say("create\t#{job_dir}")
+      FileUtils.mkdir_p(job_dir)
+
+      templates_dir = File.join(job_dir, "templates")
+      say("create\t#{templates_dir}")
+      FileUtils.mkdir_p(templates_dir)
+
+      spec_file = File.join(job_dir, "spec")
+      say("create\t#{spec_file}")
+      FileUtils.touch(spec_file)
+
+      monit_file = File.join(job_dir, "monit")
+      say("create\t#{monit_file}")
+      FileUtils.touch(monit_file)
+
+      File.open(spec_file, "w") do |f|
+        f.write("---\nname: #{name}\ntemplates:\n\npackages:\n")
+      end
+
+      say("\nGenerated skeleton for `#{name}' job in `#{job_dir}'")
+    end
+
+  end
+end

data/lib/cli/commands/job_management.rb

@@ -0,0 +1,117 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli::Command
+  class JobManagement < Base
+    include Bosh::Cli::DeploymentHelper
+
+    def start_job(*args)
+      change_job_state(:start, *args)
+    end
+
+    def stop_job(*args)
+      change_job_state(:stop, *args)
+    end
+
+    def restart_job(*args)
+      change_job_state(:restart, *args)
+    end
+
+    def recreate_job(*args)
+      change_job_state(:recreate, *args)
+    end
+
+    def change_job_state(operation, *args)
+      auth_required
+      manifest_yaml = prepare_deployment_manifest(:yaml => true)
+      manifest = YAML.load(manifest_yaml)
+
+      unless [:start, :stop, :restart, :recreate].include?(operation)
+        err("Unknown operation `#{operation}': supported operations are " +
+            "`start', `stop', `restart', `recreate'")
+      end
+
+      args  = args.dup
+      hard  = args.delete("--hard")
+      soft  = args.delete("--soft")
+      force = args.delete("--force")
+
+      if hard && soft
+        err("Cannot handle both --hard and --soft options, please choose one")
+      end
+
+      if operation != :stop && (hard || soft)
+        err("--hard and --soft options only make sense for `stop' operation")
+      end
+
+      job = args.shift
+      index = args.shift
+      deployment_desc = "`#{deployment.green}' to `#{target_name.green}'"
+      job_desc = index ? "#{job}(#{index})" : "#{job}"
+
+      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"
+      end
+
+      say("You are about to #{op_desc.green}")
+
+      if interactive?
+        # TODO: refactor inspect_deployment_changes
+        # to decouple changeset structure and rendering
+        other_changes_present = inspect_deployment_changes(
+            manifest, :show_empty_changeset => false)
+
+        if other_changes_present && !force
+          err("Cannot perform job management when other deployment changes " +
+              "are present. Please use `--force' to override.")
+        end
+        unless confirmed?("#{op_desc.capitalize}?")
+          cancel_deployment
+        end
+      end
+      nl
+
+      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}")
+    end
+
+  end
+end

data/lib/cli/commands/log_management.rb

@@ -0,0 +1,81 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli::Command
+  class LogManagement < Base
+    include Bosh::Cli::DeploymentHelper
+
+    def fetch_logs(*args)
+      auth_required
+      target_required
+
+      job = args.shift
+      index = args.shift
+      filters = nil
+
+      for_job = args.delete("--job")
+      for_agent = args.delete("--agent")
+
+      if for_job && for_agent
+        err("Please specify which logs you want, job or agent")
+      elsif for_agent
+        log_type = "agent"
+      else # default log type is 'job'
+        log_type = "job"
+      end
+
+      if args.include?("--only")
+        pos = args.index("--only")
+        filters = args[pos+1]
+        if filters.nil?
+          err("Please provide a list of filters separated by comma")
+        end
+        args.delete("--only")
+        args.delete(filters)
+      elsif args.include?("--all")
+        args.delete("--all")
+        filters = "all"
+      end
+
+      if for_agent && !filters.nil? && filters != "all"
+        err("Custom filtering is not supported for agent logs")
+      end
+
+      if index !~ /^\d+$/
+        err("Job index is expected to be a positive integer")
+      end
+
+      if args.size > 0
+        err("Unknown arguments: #{args.join(", ")}")
+      end
+
+      manifest = prepare_deployment_manifest
+
+      resource_id = director.fetch_logs(manifest["name"], job, index,
+                                        log_type, filters)
+
+      if resource_id.nil?
+        err("Error retrieving logs")
+      end
+
+      nl
+      say("Downloading log bundle (#{resource_id.to_s.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}'")
+      rescue Bosh::Cli::DirectorError => e
+        err("Unable to download logs from director: #{e}")
+      ensure
+        FileUtils.rm_rf(tmp_file) if File.exists?(tmp_file)
+      end
+
+    end
+
+  end
+end
+

data/lib/cli/commands/maintenance.rb

@@ -0,0 +1,131 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli::Command
+  class Maintenance < Base
+    include Bosh::Cli::VersionCalc
+
+    RELEASES_TO_KEEP = 2
+    STEMCELLS_TO_KEEP = 2
+
+    def cleanup
+      target_required
+      auth_required
+
+      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")
+
+      desc = <<-EOS.gsub(/^ */, "")
+        Cleanup command will attempt to delete old unused
+        release versions and stemcells from your currently
+        targeted director at #{target_name.green}.
+
+        Only #{release_wording.green} of each release
+        and #{stemcell_wording.green} of each stemcell will be kept.
+
+        Releases and stemcells that are in use will not be affected.
+      EOS
+
+      say("\n#{desc}\n")
+
+      err("Cleanup canceled") unless confirmed?
+
+      nl
+      cleanup_stemcells(stemcells_to_keep)
+      nl
+      cleanup_releases(releases_to_keep)
+
+      nl
+      say("Cleanup complete".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
+      end
+
+      delete_list = []
+      say("Deleting old stemcells")
+
+      stemcells_by_name.each_pair do |name, stemcells|
+        stemcells.sort! do |sc1, sc2|
+          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"]
+          desc = "#{name}/#{version}"
+          perform(desc) do
+            director.delete_stemcell(name, version, :quiet => true)
+          end
+        end
+      else
+        say("  none found".yellow)
+      end
+    end
+
+    def cleanup_releases(n_to_keep)
+      delete_list = []
+      say("Deleting old release versions")
+
+      director.list_releases.each do |release|
+        name = release["name"]
+        versions = release["versions"].sort { |v1, v2| version_cmp(v1, v2) }
+
+        versions[0...(-n_to_keep)].each do |version|
+          delete_list << [name, version]
+        end
+      end
+
+      if delete_list.size > 0
+        delete_list.each do |name, version|
+          desc = "#{name}/#{version}"
+          perform(desc) do
+            director.delete_release(name, :force => false,
+                                    :version => version, :quiet => true)
+          end
+        end
+      else
+        say("  none found".yellow)
+      end
+    end
+
+    def refresh(message)
+      say("\r", "")
+      say(" " * 80, "")
+      say("\r#{message}", "")
+    end
+
+    def perform(desc)
+      say("  #{desc.yellow.ljust(40)}", "")
+      say("IN PROGRESS...".yellow, "")
+
+      status, task_id = yield
+      responses = {
+        :done => "DELETED".green,
+        :non_trackable => "CANNOT TRACK".red,
+        :track_timeout => "TIMED OUT".red,
+        :error => "ERROR".red,
+      }
+
+      refresh("  #{desc.yellow.ljust(40)}#{responses[status]}\n")
+
+      if status == :error
+        task = director.get_task(task_id)
+        say("  #{task["result"].red}")
+      end
+
+      status == :done
+    end
+
+  end
+end