bosh_cli 0.16

data/README

@@ -0,0 +1,4 @@
+Copyright (c) 2009-2012 VMware, Inc.
+
+BOSH CLI is a command-line interface to VMware AppCloud Outer Shell.
+

data/Rakefile

@@ -0,0 +1,55 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+$:.unshift(File.expand_path("../../rake", __FILE__))
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __FILE__)
+
+require "rubygems"
+require "bundler"
+
+Bundler.setup(:default, :test)
+
+require "rake"
+begin
+  require "rspec/core/rake_task"
+rescue LoadError
+end
+
+require "bundler_task"
+require "ci_task"
+
+if defined?(RSpec)
+  namespace :spec do
+    SPEC_OPTS = %w(--format progress --colour)
+
+    desc "Run unit tests"
+    unit_rspec_task = RSpec::Core::RakeTask.new(:unit) do |t|
+      t.pattern = "spec/unit/**/*_spec.rb"
+      t.rspec_opts = SPEC_OPTS
+    end
+
+    CiTask.new do |task|
+      task.rspec_task = unit_rspec_task
+    end
+  end
+
+  desc "Run tests"
+  task :spec => %w(spec:unit)
+
+  desc "Run tests for CIs"
+  task "spec:ci" => %w(spec:unit:ci)
+end
+
+BundlerTask.new
+
+gem_helper = Bundler::GemHelper.new(Dir.pwd)
+
+desc "Build BOSH CLI gem into the pkg directory"
+task "build" do
+  gem_helper.build_gem
+end
+
+desc "Build and install BOSH CLI into system gems"
+task "install_head" do
+  gem_helper.install_gem
+end

data/bin/bosh

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+gemfile = File.expand_path("../../Gemfile", __FILE__)
+
+if File.exists?(gemfile)
+  ENV["BUNDLE_GEMFILE"] = gemfile
+  require "rubygems"
+  require "bundler/setup"
+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)

data/lib/cli.rb

@@ -0,0 +1,76 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh
+  module Cli
+    DEFAULT_CONFIG_PATH = File.expand_path("~/.bosh_config")
+    DEFAULT_CACHE_DIR   = File.expand_path("~/.bosh_cache")
+  end
+end
+
+autoload :HTTPClient, "httpclient"
+Bosh.autoload :Blobstore, "blobstore_client"
+
+require "base64"
+require "digest/sha1"
+require "fileutils"
+require "highline/import"
+require "json"
+require "monitor"
+require "optparse"
+require "ostruct"
+require "pathname"
+require "progressbar"
+require "set"
+require "tempfile"
+require "terminal-table/import"
+require "time"
+require "timeout"
+require "tmpdir"
+require "uri"
+require "yaml"
+require "netaddr"
+require "net/ssh"
+require "net/scp"
+require "net/ssh/gateway"
+
+unless defined?(Bosh::Cli::VERSION)
+  require "cli/version"
+end
+
+require "cli/config"
+require "cli/core_ext"
+require "cli/errors"
+require "cli/yaml_helper"
+require "cli/version_calc"
+require "cli/dependency_helper"
+require "cli/deployment_helper"
+require "cli/validation"
+require "cli/cache"
+require "cli/stemcell"
+require "cli/director"
+require "cli/director_task"
+
+require "cli/versions_index"
+require "cli/packaging_helper"
+require "cli/package_builder"
+require "cli/job_builder"
+require "cli/changeset_helper"
+require "cli/task_log_renderer"
+require "cli/event_log_renderer"
+require "cli/deployment_manifest_compiler"
+
+require "cli/release"
+require "cli/release_builder"
+require "cli/release_compiler"
+require "cli/release_tarball"
+
+require "cli/command_definition"
+require "cli/runner"
+
+YAML::ENGINE.yamler = 'syck' if defined?(YAML::ENGINE.yamler)
+
+require File.expand_path(File.dirname(__FILE__) + "/cli/commands/base")
+
+Dir[File.dirname(__FILE__) + "/cli/commands/*.rb"].each do |file|
+  require File.expand_path(file)
+end

data/lib/cli/cache.rb

@@ -0,0 +1,44 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli
+  class Cache
+
+    attr_reader :cache_dir
+
+    def initialize(cache_dir = nil)
+      @cache_dir = cache_dir || Bosh::Cli::DEFAULT_CACHE_DIR
+
+        if File.exists?(@cache_dir) && !File.directory?(@cache_dir)
+          raise CacheDirectoryError, "BOSH cache directory error: " +
+                                    "`#{@cache_dir}' is a file, not directory"
+        end
+
+        unless File.exists?(@cache_dir)
+          FileUtils.mkdir_p(@cache_dir)
+          File.chmod(0700, @cache_dir)
+        end
+      end
+
+    def read(key)
+      cached_file = path(key)
+      return nil unless File.exists?(cached_file)
+      File.read(cached_file)
+    end
+
+    def write(key, value)
+      File.open(path(key), "w") do |f|
+        f.write(value)
+      end
+    end
+
+    private
+
+    def path(key)
+      File.expand_path(hash_for(key), @cache_dir)
+    end
+
+    def hash_for(key)
+      Digest::SHA1.hexdigest(key)
+    end
+  end
+end

data/lib/cli/changeset_helper.rb

@@ -0,0 +1,142 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli
+  class HashChangeset
+    class FormatError < StandardError; end
+
+    attr_accessor :values
+
+    def initialize
+      @children = {}
+      @values   = { :old => nil, :new => nil }
+    end
+
+    def [](key)
+      @children[key.to_s]
+    end
+
+    def keys
+      @children.keys
+    end
+
+    def []=(key, value)
+      @children[key.to_s] = value
+    end
+
+    def add_hash(hash, as)
+      unless hash.is_a?(Hash)
+        raise FormatError, "Trying to add #{hash.class} to a changeset, " +
+            "Hash expected"
+      end
+
+      self.values[as] = hash
+
+      hash.each_pair do |k, v|
+        self[k] ||= HashChangeset.new
+        self[k].values[as] = v
+
+        if v.is_a?(Hash)
+          self[k].add_hash(v, as)
+        end
+      end
+    end
+
+    def leaf?
+      @children.empty?
+    end
+
+    def each(&block)
+      @children.each_value { |v| yield v }
+    end
+
+    def summary(level = 0)
+      indent = "  " * level
+      out = []
+
+      @children.each_pair do |k, v|
+        if v.state == :mismatch
+          out << indent + "#{k} type changed: ".yellow +
+              "#{v.old.class.to_s} -> #{v.new.class.to_s}"
+          out << diff(v.old, v.new, indent + "  ")
+        elsif v.leaf?
+          case v.state
+          when :added
+            out << indent + "added #{k}: ".yellow + v.new.to_s
+          when :removed
+            out << indent + "removed #{k}: ".red + v.old.to_s
+          when :changed
+            out << indent + "changed #{k}: ".yellow
+            out << diff(v.old, v.new, indent + "  ")
+          end
+        else
+          # TODO: track renames?
+          child_summary = v.summary(level + 1)
+
+          unless child_summary.empty?
+            out << indent + k
+            out << child_summary
+          end
+        end
+      end
+      out
+    end
+
+    def diff(old_value, new_value, indent)
+      old_value  = [old_value] unless old_value.kind_of?(Array)
+      new_value  = [new_value] unless new_value.kind_of?(Array)
+
+      added   = new_value - old_value
+      removed = old_value - new_value
+
+      lines = []
+
+      # Ruby 1.8 has ugly Hash#to_s, hence the normalization
+
+      removed.each do |line|
+        line = line.inspect if line.is_a?(Hash)
+        lines << "#{indent}- #{line}".red
+      end
+
+      added.each do |line|
+        line = line.inspect if line.is_a?(Hash)
+        lines << "#{indent}+ #{line}".green
+      end
+
+      lines.join("\n")
+    end
+
+    def old
+      @values[:old]
+    end
+
+    def new
+      @values[:new]
+    end
+
+    def state
+      if old.nil? && new.nil?
+        :none
+      elsif old.nil? && !new.nil?
+        :added
+      elsif !old.nil? && new.nil?
+        :removed
+      elsif old.class != new.class && !(boolean?(old) && boolean?(new))
+        :mismatch
+      elsif old == new
+        :same
+      else
+        :changed
+      end
+    end
+
+    [:added, :removed, :mismatch, :changed, :same].each do |s|
+      define_method("#{s}?".to_sym) do
+        state == s
+      end
+    end
+
+    def boolean?(value)
+      value.kind_of?(TrueClass) || value.kind_of?(FalseClass)
+    end
+  end
+end

data/lib/cli/command_definition.rb

@@ -0,0 +1,52 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli
+  class CommandDefinition
+    attr_reader :options
+    attr_reader :power_options
+    attr_reader :keywords
+
+    def initialize
+      @options = []
+      @power_options = []
+      @hints = []
+      @keywords = []
+    end
+
+    def usage(str = nil)
+      if str
+        @usage = str.strip
+        @keywords = str.split(/\s+/).select do |word|
+          word.match(/^[a-z]/i)
+        end
+      else
+        @usage
+      end
+    end
+
+    def description(str = nil)
+      str ? (@description = str.to_s.strip) : @description
+    end
+
+    alias :desc :description
+
+    def option(name, value = "")
+      @options << [name, value]
+    end
+
+    def power_option(name, value = "")
+      @power_options << [name, value]
+    end
+
+    def route(*args, &block)
+      if args.size > 0
+        @route = args
+      elsif block_given?
+        @route = block
+      else
+        @route
+      end
+    end
+  end
+end
+

data/lib/cli/commands/base.rb

@@ -0,0 +1,245 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Cli
+  module Command
+    class Base
+      BLOBS_DIR = "blobs"
+      BLOBS_INDEX_FILE = "blob_index.yml"
+
+      attr_reader :cache, :config, :options, :work_dir
+      attr_accessor :out, :usage
+
+      def initialize(options = {})
+        @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)
+      end
+
+      class << self
+        attr_reader :commands
+
+        def command(name, &block)
+          @commands ||= {}
+          @commands[name] = block
+        end
+      end
+
+      def director
+        @director ||= Bosh::Cli::Director.new(target, username, password)
+      end
+
+      def release
+        return @release if @release
+        check_if_release_dir
+        @release = Bosh::Cli::Release.new(@work_dir)
+      end
+
+      def blobstore
+        release.blobstore
+      end
+
+      def logged_in?
+        username && password
+      end
+
+      def non_interactive?
+        !interactive?
+      end
+
+      def interactive?
+        !options[:non_interactive]
+      end
+
+      def verbose?
+        options[:verbose]
+      end
+
+      # TODO: implement it
+      def dry_run?
+        options[:dry_run]
+      end
+
+      def show_usage
+        say("Usage: #{@usage}") if @usage
+      end
+
+      def run(namespace, action, *args)
+        eval(namespace.to_s.capitalize).new(options).send(action.to_sym, *args)
+      end
+
+      def redirect(*args)
+        run(*args)
+        raise Bosh::Cli::GracefulExit, "redirected to %s" % [args.join(" ")]
+      end
+
+      def confirmed?(question = "Are you sure?")
+        non_interactive? ||
+            ask("#{question} (type 'yes' to continue): ") == "yes"
+      end
+
+      [:username, :password, :target, :deployment].each do |attr_name|
+        define_method attr_name do
+          config.send(attr_name)
+        end
+      end
+
+      alias_method :target_url, :target
+
+      def target_name
+        config.target_name || target_url
+      end
+
+      def target_version
+        config.target_version ? "Ver: " + config.target_version : ""
+      end
+
+      def full_target_name
+        # TODO refactor this method
+        ret = (target_name.blank? || target_name == target_url ?
+            target_name : "%s (%s)" % [target_name, target_url])
+        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
+        target_required
+        err("Please log in first") unless logged_in?
+      end
+
+      def target_required
+        err("Please choose target first") if target.nil?
+      end
+
+      def deployment_required
+        err("Please choose deployment first") if deployment.nil?
+      end
+
+      def check_if_release_dir
+        unless in_release_dir?
+          err("Sorry, your current directory doesn't look " +
+              "like release directory")
+        end
+      end
+
+      def check_if_dirty_state
+        if dirty_state?
+          say("\n%s\n" % [`git status`])
+          err("Your current directory has some local modifications, " +
+              "please discard or commit them first")
+        end
+      end
+
+      def in_release_dir?
+        File.directory?("packages") &&
+            File.directory?("jobs") &&
+            File.directory?("src")
+      end
+
+      def dirty_state?
+        `which git`
+        return false unless $? == 0
+        File.directory?(".git") && `git status --porcelain | wc -l`.to_i > 0
+      end
+
+      def normalize_url(url)
+        url = "http://#{url}" unless url.match(/^https?/)
+        URI.parse(url).to_s
+      end
+
+      def check_if_blobs_supported
+        check_if_release_dir
+        unless File.directory?(BLOBS_DIR)
+          err("Can't find blob directory '#{BLOBS_DIR}'.")
+        end
+
+        unless File.file?(BLOBS_INDEX_FILE)
+          err("Can't find '#{BLOBS_INDEX_FILE}'")
+        end
+      end
+
+      def check_dirty_blobs
+        if File.file?(File.join(work_dir, BLOBS_INDEX_FILE)) && blob_status != 0
+          err("Your 'blobs' directory is not in sync. " +
+                  "Resolve using 'bosh sync blobs' command")
+        end
+      end
+
+      def get_blobs_index
+        load_yaml_file(File.join(work_dir, BLOBS_INDEX_FILE))
+      end
+
+      def blob_status(verbose = false)
+        check_if_blobs_supported
+        untracked = []
+        modified = []
+        tracked= []
+        unsynced = []
+
+        local_blobs = {}
+        Dir.chdir(BLOBS_DIR) do
+          Dir.glob("**/*").select { |entry| File.file?(entry) }.each do |file|
+            local_blobs[file] = Digest::SHA1.file(file).hexdigest
+          end
+        end
+        remote_blobs = get_blobs_index
+
+        local_blobs.each do |blob_name, blob_sha|
+          if remote_blobs[blob_name].nil?
+            untracked << blob_name
+          elsif blob_sha != remote_blobs[blob_name]["sha"]
+            modified << blob_name
+          else
+            tracked << blob_name
+          end
+        end
+
+        remote_blobs.each_key do |blob_name|
+          unsynced << blob_name if local_blobs[blob_name].nil?
+        end
+
+        changes = modified.size + untracked.size + unsynced.size
+        return changes unless verbose
+
+        if modified.size > 0
+          say("\nModified blobs ('bosh upload blob' to update): ".green)
+          modified.each { |blob| say(blob) }
+        end
+
+        if untracked.size > 0
+          say("\nNew blobs ('bosh upload blob' to add): ".green)
+          untracked.each { |blob| say(blob) }
+        end
+
+        if unsynced.size > 0
+          say("\nMissing blobs ('bosh sync blobs' to fetch) : ".green)
+          unsynced.each { |blob| say(blob) }
+        end
+
+        if changes == 0
+          say("\nRelease blobs are up to date".green)
+        end
+        changes
+      end
+    end
+  end
+end