bosh_cli 0.16

data/lib/cli/core_ext.rb

@@ -0,0 +1,145 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module BoshExtensions
+
+  def say(message, sep = "\n")
+    return unless Bosh::Cli::Config.output && message
+    message = message.dup.to_s
+    sep = "" if message[-1..-1] == sep
+    Bosh::Cli::Config.output.print("#{$indent}#{message}#{sep}")
+  end
+
+  def with_indent(indent)
+    old_indent, $indent = $indent, old_indent.to_s + indent.to_s
+    yield
+  ensure
+    $indent = old_indent
+  end
+
+  def header(message, filler = '-')
+    say("\n")
+    say(message)
+    say(filler.to_s * message.size)
+  end
+
+  def nl(count = 1)
+    say("\n" * count)
+  end
+
+  def err(message)
+    raise Bosh::Cli::CliExit.new message
+  end
+
+  def quit(message = nil)
+    say(message)
+    raise Bosh::Cli::GracefulExit, message
+  end
+
+  def blank?
+    self.to_s.blank?
+  end
+
+  def pretty_size(what, prec=1)
+    if what.is_a?(String) && File.exists?(what)
+      size = File.size(what)
+    else
+      size = what.to_i
+    end
+
+    return "NA" unless size
+    return "#{size}B" if size < 1024
+    return sprintf("%.#{prec}fK", size/1024.0) if size < (1024*1024)
+    if size < (1024*1024*1024)
+      return sprintf("%.#{prec}fM", size/(1024.0*1024.0))
+    end
+    sprintf("%.#{prec}fG", size/(1024.0*1024.0*1024.0))
+  end
+
+  def pluralize(number, singular, plural = nil)
+    plural = plural || "#{singular}s"
+    number == 1 ? "1 #{singular}" : "#{number} #{plural}"
+  end
+
+  def format_time(time)
+    ts = time.to_i
+    sprintf("%02d:%02d:%02d", ts / 3600, (ts / 60) % 60, ts % 60);
+  end
+
+  def load_yaml_file(path, expected_type = Hash)
+    err("Cannot find file `#{path}'") unless File.exists?(path)
+    yaml = YAML.load_file(path)
+
+    if expected_type && !yaml.is_a?(expected_type)
+      err("Incorrect file format in `#{path}', #{expected_type} expected")
+    end
+
+    Bosh::Cli::YamlHelper.check_duplicate_keys(path)
+
+    yaml
+  rescue SystemCallError => e
+    err("Cannot load YAML file at `#{path}': #{e}")
+  end
+
+  def dump_yaml_to_file(obj, file)
+    yaml = YAML.dump(obj)
+    file.write(yaml.gsub(" \n", "\n"))
+    file.flush
+  end
+end
+
+module BoshStringExtensions
+
+  COLOR_CODES = {
+    :red => "\e[0m\e[31m",
+    :green => "\e[0m\e[32m",
+    :yellow => "\e[0m\e[33m"
+  }
+
+  def red
+    colorize(:red)
+  end
+
+  def green
+    colorize(:green)
+  end
+
+  def yellow
+    colorize(:yellow)
+  end
+
+  def colorize(color_code)
+    if Bosh::Cli::Config.colorize && COLOR_CODES[color_code]
+      "#{COLOR_CODES[color_code]}#{self}\e[0m"
+    else
+      self
+    end
+  end
+
+  def blank?
+    self =~ /^\s*$/
+  end
+
+  def bosh_valid_id?
+    self =~ Bosh::Cli::Config::VALID_ID
+  end
+
+  def truncate(limit = 30)
+    return "" if self.blank?
+    etc = "..."
+    stripped = self.strip[0..limit]
+    if stripped.length > limit
+      stripped.gsub(/\s+?(\S+)?$/, "") + etc
+    else
+      stripped
+    end
+  end
+
+end
+
+class Object
+  include BoshExtensions
+end
+
+class String
+  include BoshStringExtensions
+end

data/lib/cli/dependency_helper.rb

@@ -0,0 +1,62 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli
+  module DependencyHelper
+
+    # Expects package dependency graph
+    # { "A" => ["B", "C"], "B" => ["C", "D"] }
+    def tsort_packages(map)
+      resolved = Set.new
+      in_degree = { }
+      graph = { }
+
+      map.keys.sort.each do |package|
+        dependencies = map[package]
+        graph[package] ||= Set.new
+        in_degree[package] = dependencies.size
+
+        resolved << package if in_degree[package] == 0
+
+        # Reverse edges to avoid dfs
+        dependencies.each do |dependency|
+          unless map.has_key?(dependency)
+            raise MissingDependency, ("Package '%s' depends on " +
+                "missing package '%s'") % [package, dependency]
+          end
+
+          graph[dependency] ||= Set.new
+          graph[dependency] << package
+        end
+      end
+
+      sorted = []
+
+      until resolved.empty?
+        p = resolved.first
+        resolved.delete(p)
+
+        sorted << p
+
+        graph[p].each do |v|
+          in_degree[v] -= 1
+          resolved << v if in_degree[v] == 0
+        end
+        graph[p].clear
+      end
+
+      # each_pair gives different (correct) results in 1.8 in 1.9,
+      # stabilizing for tests
+      graph.keys.sort.each do |v|
+        e = graph[v]
+        unless e.empty?
+          raise CircularDependency, ("Cannot resolve dependencies for '%s': " +
+              "circular dependency with '%s'") % [v, e.first]
+        end
+      end
+
+      sorted
+    end
+  end
+
+end
+

data/lib/cli/deployment_helper.rb

@@ -0,0 +1,263 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli
+  module DeploymentHelper
+
+    def prepare_deployment_manifest(options = {})
+      # TODO: extract to helper class
+      deployment_required
+      manifest_filename = deployment
+
+      unless File.exists?(manifest_filename)
+        err("Cannot find deployment manifest in `#{manifest_filename}'")
+      end
+
+      manifest = load_yaml_file(manifest_filename)
+      manifest_yaml = File.read(manifest_filename)
+
+      if manifest["name"].blank?
+        err("Deployment name not found in the deployment manifest")
+      end
+
+      if manifest["target"]
+        err(manifest_target_upgrade_notice)
+      end
+
+      if options[:resolve_properties]
+        compiler = DeploymentManifestCompiler.new(manifest_yaml)
+        properties = {}
+
+        begin
+          say("Getting deployment properties from director...")
+          properties = director.list_properties(manifest["name"])
+        rescue Bosh::Cli::DirectorError
+          say("Unable to get properties list from director, " +
+                  "trying without it...")
+        end
+
+        say("Compiling deployment manifest...")
+        compiler.properties = properties.inject({}) do |hash, property|
+          hash[property["name"]] = property["value"]
+          hash
+        end
+
+        manifest_yaml = compiler.result
+        manifest = YAML.load(manifest_yaml)
+      end
+
+      if manifest["name"].blank? || manifest["release"].blank? ||
+          manifest["director_uuid"].blank?
+        err("Invalid manifest `#{File.basename(deployment)}': " +
+                "name, release and director UUID are all required")
+      end
+
+      options[:yaml] ? manifest_yaml : manifest
+    end
+
+    # Interactive walkthrough of deployment changes,
+    # expected to bail out of CLI using 'cancel_deployment'
+    # if something goes wrong, so it doesn't need to have
+    # a meaningful return value.
+    # @return Boolean Were there any changes in deployment manifest?
+    def inspect_deployment_changes(manifest, options = { })
+      show_empty_changeset = true
+
+      if options.has_key?(:show_empty_changeset)
+        show_empty_changeset = options[:show_empty_changeset]
+      end
+
+      manifest = manifest.dup
+      current_deployment = director.get_deployment(manifest["name"])
+
+      # We cannot retrieve current manifest until there was at least one
+      # successful deployment. There used to be a warning about that
+      # but it turned out to be confusing to many users and thus has
+      # been removed.
+      return if current_deployment["manifest"].nil?
+      current_manifest = YAML.load(current_deployment["manifest"])
+
+      unless current_manifest.is_a?(Hash)
+        err("Current deployment manifest format is invalid, " +
+                "check if director works properly")
+      end
+
+      # TODO: validate new deployment manifest
+      diff = Bosh::Cli::HashChangeset.new
+      diff.add_hash(normalize_deployment_manifest(manifest), :new)
+      diff.add_hash(normalize_deployment_manifest(current_manifest), :old)
+      @_diff_key_visited = { "name" => 1, "director_uuid" => 1 }
+
+      say("Detecting changes in deployment...".green)
+      nl
+
+      if !diff.changed? && !show_empty_changeset
+        return false
+      end
+
+      print_summary(diff, :release)
+
+      if diff[:release][:name].changed?
+        say("Release name has changed: %s -> %s".red % [
+            diff[:release][:name].old, diff[:release][:name].new])
+        unless confirmed?("This is very serious and potentially destructive " +
+                              "change. ARE YOU SURE YOU WANT TO DO IT?")
+          cancel_deployment
+        end
+      elsif diff[:release][:version].changed?
+        say("Release version has changed: %s -> %s".yellow % [
+            diff[:release][:version].old, diff[:release][:version].new])
+        unless confirmed?("Are you sure you want to deploy this version?")
+          cancel_deployment
+        end
+      end
+      nl
+
+      print_summary(diff, :compilation)
+      nl
+
+      print_summary(diff, :update)
+      nl
+
+      print_summary(diff, :resource_pools)
+
+      old_stemcells = Set.new
+      new_stemcells = Set.new
+
+      diff[:resource_pools].each do |pool|
+        old_stemcells << {
+            :name => pool[:stemcell][:name].old,
+            :version => pool[:stemcell][:version].old
+        }
+        new_stemcells << {
+            :name => pool[:stemcell][:name].new,
+            :version => pool[:stemcell][:version].new
+        }
+      end
+
+      if old_stemcells != new_stemcells
+        unless confirmed?("Stemcell update has been detected. " +
+                          "Are you sure you want to update stemcells?")
+          cancel_deployment
+        end
+      end
+
+      if old_stemcells.size != new_stemcells.size
+        say("Stemcell update seems to be inconsistent with current " +
+            "deployment. Please carefully review changes above.".red)
+        unless confirmed?("Are you sure this configuration is correct?")
+          cancel_deployment
+        end
+      end
+
+      nl
+      print_summary(diff, :networks)
+      nl
+      print_summary(diff, :jobs)
+      nl
+      print_summary(diff, :properties)
+      nl
+
+      diff.keys.each do |key|
+        unless @_diff_key_visited[key]
+          print_summary(diff, key)
+          nl
+        end
+      end
+
+      diff.changed?
+    rescue Bosh::Cli::DeploymentNotFound
+      say("Cannot get current deployment information from director, " +
+          "possibly a new deployment".red)
+      true
+    end
+
+    private
+
+    def find_deployment(name)
+      if File.exists?(name)
+        File.expand_path(name)
+      else
+        File.expand_path(File.join(work_dir, "deployments", "#{name}.yml"))
+      end
+    end
+
+    def cancel_deployment
+      quit("Deployment canceled".red)
+    end
+
+    def manifest_error(err)
+      err("Deployment manifest error: #{err}")
+    end
+
+    def manifest_target_upgrade_notice
+      <<-EOS.gsub(/^\s*/, "").gsub(/\n$/, "")
+        Please upgrade your deployment manifest to use director UUID instead
+        of target. Just replace 'target' key with 'director_uuid' key in your
+        manifest. You can get your director UUID by targeting your director
+        with 'bosh target' and running 'bosh status' command afterwards.
+      EOS
+    end
+
+    def print_summary(diff, key, title = nil)
+      title ||= key.to_s.gsub(/[-_]/, " ").capitalize
+
+      say(title.green)
+      summary = diff[key].summary
+      if summary.empty?
+        say("No changes")
+      else
+        say(summary.join("\n"))
+      end
+      @_diff_key_visited[key.to_s] = 1
+    end
+
+    def normalize_deployment_manifest(manifest)
+      normalized = manifest.dup
+
+      %w(networks jobs resource_pools).each do |section|
+        unless normalized[section].kind_of?(Array)
+          manifest_error("#{section} is expected to be an array")
+        end
+
+        normalized[section] = normalized[section].inject({}) do |acc, e|
+          if e["name"].blank?
+            manifest_error("missing name for one of entries in '#{section}'")
+          end
+          if acc.has_key?(e["name"])
+            manifest_error("duplicate entry '#{e['name']}' in '#{section}'")
+          end
+          acc[e["name"]] = e
+          acc
+        end
+      end
+
+      normalized["networks"].each do |network_name, network|
+        # VIP and dynamic networks do not require subnet,
+        # but if it's there we can run some sanity checks
+        next unless network.has_key?("subnets")
+
+        unless network["subnets"].kind_of?(Array)
+          manifest_error("network subnets is expected to be an array")
+        end
+
+        subnets = network["subnets"].inject({}) do |acc, e|
+          if e["range"].blank?
+            manifest_error("missing range for one of subnets " +
+                               "in '#{network_name}'")
+          end
+          if acc.has_key?(e["range"])
+            manifest_error("duplicate network range '#{e['range']}' " +
+                               "in '#{network}'")
+          end
+          acc[e["range"]] = e
+          acc
+        end
+
+        normalized["networks"][network_name]["subnets"] = subnets
+      end
+
+      normalized
+    end
+
+  end
+end