bosh_cli 1.0.3 → 1.5.0.pre.1113

data/lib/cli/commands/misc.rb

@@ -15,58 +15,53 @@ module Bosh::Cli::Command
     usage "status"
     desc  "Show current status (current target, user, deployment info etc)"
     def status
-      cpi = nil
-      features = nil
-
-      if config.target
-        say("Updating director data...", " ")
+      say("Config".make_green)
+      print_value("", config.filename)
 
+      nl
+      say("Director".make_green)
+      if target.nil?
+        say("  not set".make_yellow)
+      else
         begin
           timeout(config.status_timeout || DEFAULT_STATUS_TIMEOUT) do
-            director = Bosh::Cli::Director.new(config.target)
+            director = Bosh::Cli::Client::Director.new(target)
             status = director.get_status
 
-            config.target_name = status["name"]
-            config.target_version = status["version"]
-            config.target_uuid = status["uuid"]
-            cpi = status["cpi"]
-            features = status["features"]
-            config.save
-            say("done".green)
+            print_value("Name", status["name"])
+            print_value("URL", target_url)
+            print_value("Version", status["version"])
+            print_value("User", username, "not logged in")
+            print_value("UUID", status["uuid"])
+            print_value("CPI", status["cpi"], "n/a")
+            print_feature_list(status["features"]) if status["features"]
+
+            unless options[:target]
+              config.target_name = status["name"]
+              config.target_version = status["version"]
+              config.target_uuid = status["uuid"]
+              config.save
+            end
           end
         rescue TimeoutError
-          say("timed out".red)
+          say("  timed out fetching director status".make_red)
         rescue => e
-          say("error: #{e.message}")
+          say("  error fetching director status: #{e.message}".make_red)
         end
-        nl
-      end
-
-      say("Director".green)
-      if target_url.nil?
-        say("  not set".yellow)
-      else
-        print_value("Name", config.target_name)
-        print_value("URL", target_url)
-        print_value("Version", config.target_version)
-        print_value("User", username, "not logged in")
-        print_value("UUID", config.target_uuid)
-        print_value("CPI", cpi, "n/a (update director)")
-        print_feature_list(features) if features
       end
 
       nl
-      say("Deployment".green)
+      say("Deployment".make_green)
 
       if deployment
         print_value("Manifest", deployment)
       else
-        say("  not set".yellow)
+        say("  not set".make_yellow)
       end
 
       if in_release_dir?
         nl
-        say("Release".green)
+        say("Release".make_green)
 
         dev_version = Bosh::Cli::VersionsIndex.new(
           File.join(work_dir, "dev_releases")).latest_version
@@ -87,7 +82,10 @@ module Bosh::Cli::Command
 
     # bosh login
     usage "login"
-    desc  "Log in to currently targeted director"
+    desc  "Log in to currently targeted director. " +
+          "The username and password can also be " +
+          "set in the BOSH_USER and BOSH_PASSWORD " +
+          "environment variables."
     def login(username = nil, password = nil)
       target_required
 
@@ -106,16 +104,20 @@ module Bosh::Cli::Command
       end
       logged_in = false
 
+      #Converts HighLine::String to String
+      username = username.to_s
+      password = password.to_s
+
       director.user = username
       director.password = password
 
       if director.authenticated?
-        say("Logged in as `#{username}'".green)
+        say("Logged in as `#{username}'".make_green)
         logged_in = true
       elsif non_interactive?
-        err("Cannot log in as `#{username}'".red)
+        err("Cannot log in as `#{username}'".make_red)
       else
-        say("Cannot log in as `#{username}', please try again".red)
+        say("Cannot log in as `#{username}', please try again".make_red)
         login(username)
       end
 
@@ -132,7 +134,7 @@ module Bosh::Cli::Command
       target_required
       config.set_credentials(target, nil, nil)
       config.save
-      say("You are no longer logged in to `#{target}'".yellow)
+      say("You are no longer logged in to `#{target}'".make_yellow)
     end
 
     # bosh purge
@@ -143,7 +145,7 @@ module Bosh::Cli::Command
         err("Cache directory overriden, please remove manually")
       else
         FileUtils.rm_rf(cache.cache_dir)
-        say("Purged cache".green)
+        say("Purged cache".make_green)
       end
     end
 
@@ -168,11 +170,11 @@ module Bosh::Cli::Command
 
       director_url = normalize_url(director_url)
       if target && director_url == normalize_url(target)
-        say("Target already set to `#{target_name.green}'")
+        say("Target already set to `#{target_name.make_green}'")
         return
       end
 
-      director = Bosh::Cli::Director.new(director_url)
+      director = Bosh::Cli::Client::Director.new(director_url)
 
       begin
         status = director.get_status
@@ -197,7 +199,7 @@ module Bosh::Cli::Command
       end
 
       config.save
-      say("Target set to `#{target_name.green}'")
+      say("Target set to `#{target_name.make_green}'")
 
       if interactive? && !logged_in?
         redirect("login")
@@ -229,7 +231,7 @@ module Bosh::Cli::Command
     def set_alias(name, command)
       config.set_alias(:cli, name, command.to_s.strip)
       config.save
-      say("Alias `#{name.green}' created for command `#{command.green}'")
+      say("Alias `#{name.make_green}' created for command `#{command.make_green}'")
     end
 
     # bosh aliases
@@ -255,9 +257,9 @@ module Bosh::Cli::Command
 
     def print_value(label, value, if_none = nil)
       if value
-        message = label.ljust(10) + value.yellow
+        message = label.ljust(10) + ' ' + value.make_yellow
       else
-        message = label.ljust(10) + (if_none || "n/a").yellow
+        message = label.ljust(10) + ' ' + (if_none || "n/a").make_yellow
       end
       say(message.indent(2))
     end
@@ -270,7 +272,7 @@ module Bosh::Cli::Command
           else
             name = config.target
           end
-          say("Current target is #{name.green}")
+          say("Current target is #{name.make_green}")
         else
           say(config.target)
         end
@@ -310,7 +312,7 @@ module Bosh::Cli::Command
             t << [name, dev_version.gsub(/\-dev$/, "").rjust(8),
                   final_version.to_s.rjust(8)]
           rescue Bosh::Cli::InvalidIndex => e
-            say("Problem with #{entity} index for `#{name}': #{e.message}".red)
+            say("Problem with #{entity} index for `#{name}': #{e.message}".make_red)
           end
         else
           say("Spec file `#{spec_file}' is invalid")
@@ -322,22 +324,41 @@ module Bosh::Cli::Command
 
     def print_feature_list(features)
       if features.respond_to?(:each)
-        features.each do |feature, status|
-          print_value(feature, format_feature_status(status))
+        features.each do |feature, info|
+          # Old director only returns status as a Boolean
+          if info.kind_of?(Hash)
+            status = info["status"]
+            extras = info["extras"]
+          else
+            status = info
+            extras = nil
+          end
+          print_value(feature, format_feature_status(status, extras))
         end
       else
-        say("Unknown feature list: #{features.inspect}".red)
+        say("Unknown feature list: #{features.inspect}".make_red)
       end
     end
 
-    def format_feature_status(status)
+    def format_feature_status(status, extras)
       if status.nil?
         "n/a"
       elsif status
-        "enabled"
+        "enabled #{format_feature_extras(extras)}"
       else
         "disabled"
       end
     end
+
+    def format_feature_extras(extras)
+      return "" if extras.nil? || extras.empty?
+
+      result = []
+      extras.each do |name, value|
+        result << "#{name}: #{value}"
+      end
+
+      "(#{result.join(", ")})"
+    end
   end
 end

data/lib/cli/commands/package.rb

@@ -22,12 +22,12 @@ module Bosh::Cli::Command
       FileUtils.mkdir_p(package_dir)
 
       generate_file(package_dir, "packaging") do
-        "# abort script on any command that exit " +
+        "# abort script on any command that exits " +
         "with a non zero value\nset -e\n"
       end
 
       generate_file(package_dir, "pre_packaging") do
-        "# abort script on any command that exit " +
+        "# abort script on any command that exits " +
         "with a non zero value\nset -e\n"
       end
 

data/lib/cli/commands/property_management.rb

@@ -2,8 +2,6 @@
 
 module Bosh::Cli::Command
   class PropertyManagement < Base
-    include Bosh::Cli::DeploymentHelper
-
     # bosh set property
     usage "set property"
     desc "Set deployment property"
@@ -19,14 +17,14 @@ module Bosh::Cli::Command
       end
 
       if existing_property
-        say("Current `#{name.green}' value is " +
-            "`#{format_property(body["value"]).green}'")
+        say("Current `#{name.make_green}' value is " +
+            "`#{format_property(body["value"]).make_green}'")
       else
         say("This will be a new property")
       end
 
       prompt = "Are you sure you want to set property" +
-        " `#{name.green}' to `#{format_property(value).green}'?"
+        " `#{name.make_green}' to `#{format_property(value).make_green}'?"
 
       unless confirmed?(prompt)
         err("Canceled")
@@ -39,7 +37,7 @@ module Bosh::Cli::Command
       end
 
       if status == 204
-        say("Property `#{name.green}' set to `#{value.green}'")
+        say("Property `#{name.make_green}' set to `#{value.make_green}'")
       else
         err(director.parse_error_message(status, body))
       end
@@ -53,7 +51,7 @@ module Bosh::Cli::Command
       show_header
 
       prompt = "Are you sure you want to unset property " +
-        "`#{name.green}'?"
+        "`#{name.make_green}'?"
 
       unless confirmed?(prompt)
         err("Canceled")
@@ -62,7 +60,7 @@ module Bosh::Cli::Command
       status, body = director.delete_property(@deployment_name, name)
 
       if status == 204
-        say("Property `#{name.green}' has been unset")
+        say("Property `#{name.make_green}' has been unset")
       else
         err(director.parse_error_message(status, body))
       end
@@ -77,8 +75,8 @@ module Bosh::Cli::Command
 
       status, body = director.get_property(@deployment_name, name)
       if status == 200
-        say("Property `#{name.green}' value is " +
-            "`#{format_property(body["value"]).green}'")
+        say("Property `#{name.make_green}' value is " +
+            "`#{format_property(body["value"]).make_green}'")
       else
         err(director.parse_error_message(status, body))
       end
@@ -128,8 +126,8 @@ module Bosh::Cli::Command
     end
 
     def show_header
-      say("Target #{target_name.green}")
-      say("Deployment #{@deployment_name.green}")
+      say("Target #{target_name.make_green}")
+      say("Deployment #{@deployment_name.make_green}")
       nl
     end
 

data/lib/cli/commands/release.rb

@@ -26,16 +26,15 @@ module Bosh::Cli::Command
 
       # Initialize an empty blobs index
       File.open(File.join("config", "blobs.yml"), "w") do |f|
-        YAML.dump({}, f)
+        Psych.dump({}, f)
       end
 
-      say("Release directory initialized".green)
+      say("Release directory initialized".make_green)
     end
 
     # bosh create release
     usage "create release"
-    desc "Create release (assumes current directory " +
-         "to be a release repository)"
+    desc "Create release (assumes current directory to be a release repository)"
     option "--force", "bypass git dirty state check"
     option "--final", "create final release"
     option "--with-tarball", "create release tarball"
@@ -67,54 +66,57 @@ module Bosh::Cli::Command
       nl
 
       if tarball.valid?
-        say("`#{tarball_path}' is a valid release".green)
+        say("`#{tarball_path}' is a valid release".make_green)
       else
-        say("Validation errors:".red)
+        say("Validation errors:".make_red)
         tarball.errors.each do |error|
           say("- #{error}")
         end
-        err("`#{tarball_path}' is not a valid release".red)
+        err("`#{tarball_path}' is not a valid release".make_red)
       end
     end
 
     usage "upload release"
-    desc "Upload release"
+    desc "Upload release (release_file can be a local file or a remote URI)"
     option "--rebase",
            "Rebases this release onto the latest version",
            "known by director (discards local job/package",
            "versions in favor of versions assigned by director)"
+    option "--skip-if-exists", "skips upload if release already exists"
     def upload(release_file = nil)
       auth_required
 
       upload_options = {
         :rebase => options[:rebase],
-        :repack => true
+        :repack => true,
+        :skip_if_exists => options[:skip_if_exists],
       }
 
       if release_file.nil?
         check_if_release_dir
         release_file = release.latest_release_filename
         if release_file.nil?
-          err("The information about latest generated release is missing, " +
-              "please provide release filename")
+          err("The information about latest generated release is missing, please provide release filename")
         end
-        unless confirmed?("Upload release " +
-                          "`#{File.basename(release_file).green}' " +
-                          "to `#{target_name.green}'")
+        unless confirmed?("Upload release `#{File.basename(release_file).make_green}' to `#{target_name.make_green}'")
           err("Canceled upload")
         end
       end
 
-      unless File.exist?(release_file)
-        err("Release file doesn't exist")
-      end
+      if release_file =~ /^#{URI::regexp}$/
+        upload_remote_release(release_file, upload_options)
+      else
+        unless File.exist?(release_file)
+          err("Release file doesn't exist")
+        end
 
-      file_type = `file --mime-type -b '#{release_file}'`
+        file_type = `file --mime-type -b '#{release_file}'`
 
-      if file_type =~ /text\/(plain|yaml)/
-        upload_manifest(release_file, upload_options)
-      else
-        upload_tarball(release_file, upload_options)
+        if file_type =~ /text\/(plain|yaml)/
+          upload_manifest(release_file, upload_options)
+        else
+          upload_tarball(release_file, upload_options)
+        end
       end
     end
 
@@ -123,7 +125,7 @@ module Bosh::Cli::Command
     def reset
       check_if_release_dir
 
-      say("Your dev release environment will be completely reset".red)
+      say("Your dev release environment will be completely reset".make_red)
       if confirmed?
         say("Removing dev_builds index...")
         FileUtils.rm_rf(".dev_builds")
@@ -133,7 +135,7 @@ module Bosh::Cli::Command
         say("Removing dev tarballs...")
         FileUtils.rm_rf("dev_releases")
 
-        say("Release has been reset".green)
+        say("Release has been reset".make_green)
       else
         say("Canceled")
       end
@@ -141,6 +143,7 @@ module Bosh::Cli::Command
 
     usage "releases"
     desc "Show the list of available releases"
+    option "--jobs", "include job templates"
     def list
       auth_required
       releases = director.list_releases.sort do |r1, r2|
@@ -149,20 +152,16 @@ module Bosh::Cli::Command
 
       err("No releases") if releases.empty?
 
-      releases_table = table do |t|
-        t.headings = "Name", "Versions"
-        releases.each do |r|
-          versions = r["versions"].sort { |v1, v2|
-            version_cmp(v1, v2)
-          }.map { |v| ((r["in_use"] || []).include?(v)) ? "#{v}*" : v }
-
-          t << [r["name"], versions.join(", ")]
-        end
+      if releases.first.has_key? "release_versions"
+        releases_table = build_releases_table(releases, options)
+      elsif releases.first.has_key? "versions"
+        releases_table = build_releases_table_for_old_director(releases)
       end
 
       nl
-      say(releases_table)
+      say(releases_table.render)
       say("(*) Currently deployed") if releases_table.to_s =~ /\*/
+      say("(+) Uncommitted changes") if releases_table.to_s =~ /^\|.*\+{1}.*\|$/
       nl
       say("Releases total: %d" % releases.size)
     end
@@ -178,20 +177,20 @@ module Bosh::Cli::Command
       desc << "/#{version}" if version
 
       if force
-        say("Deleting `#{desc}' (FORCED DELETE, WILL IGNORE ERRORS)".red)
+        say("Deleting `#{desc}' (FORCED DELETE, WILL IGNORE ERRORS)".make_red)
       else
-        say("Deleting `#{desc}'".red)
+        say("Deleting `#{desc}'".make_red)
       end
 
       if confirmed?
-        status, task_id = director.delete_release(
-          name, :force => force, :version => version)
+        status, task_id = director.delete_release(name, force: force, version: version)
         task_report(status, task_id, "Deleted `#{desc}'")
       else
-        say("Canceled deleting release".green)
+        say("Canceled deleting release".make_green)
       end
     end
 
+
     protected
 
     def upload_manifest(manifest_path, upload_options = {})
@@ -202,8 +201,7 @@ module Bosh::Cli::Command
       blobstore = release.blobstore
       tmpdir = Dir.mktmpdir
 
-      compiler = Bosh::Cli::ReleaseCompiler.new(
-        manifest_path, blobstore, package_matches)
+      compiler = Bosh::Cli::ReleaseCompiler.new(manifest_path, blobstore, package_matches)
       need_repack = true
 
       unless compiler.exists?
@@ -230,24 +228,29 @@ module Bosh::Cli::Command
         err("Release is invalid, please fix, verify and upload again")
       end
 
-      begin
-        remote_release = get_remote_release(tarball.release_name) rescue nil
-
-        if remote_release && !rebase &&
-          remote_release["versions"].include?(tarball.version)
-          err("This release version has already been uploaded")
+      remote_release = get_remote_release(tarball.release_name) rescue nil
+      if remote_release && !rebase
+        if remote_release["versions"].include?(tarball.version)
+          if upload_options[:skip_if_exists]
+            say("Release `#{tarball.release_name}/#{tarball.version}' already exists. Skipping upload.")
+            return
+          else
+            err("This release version has already been uploaded")
+          end
         end
+      end
 
+      begin
         if repack
           package_matches = match_remote_packages(tarball.manifest)
 
           say("Checking if can repack release for faster upload...")
           repacked_path = tarball.repack(package_matches)
+
           if repacked_path.nil?
-            say("Uploading the whole release".green)
+            say("Uploading the whole release".make_green)
           else
-            say("Release repacked " +
-                "(new size is #{pretty_size(repacked_path)})".green)
+            say("Release repacked (new size is #{pretty_size(repacked_path)})".make_green)
             tarball_path = repacked_path
           end
         end
@@ -257,7 +260,7 @@ module Bosh::Cli::Command
       end
 
       if rebase
-        say("Uploading release (#{"will be rebased".yellow})")
+        say("Uploading release (#{"will be rebased".make_yellow})")
         status, task_id = director.rebase_release(tarball_path)
         task_report(status, task_id, "Release rebased")
       else
@@ -267,6 +270,19 @@ module Bosh::Cli::Command
       end
     end
 
+    def upload_remote_release(release_location, upload_options = {})
+      nl
+      if upload_options[:rebase]
+        say("Using remote release `#{release_location}' (#{"will be rebased".make_yellow})")
+        status, task_id = director.rebase_remote_release(release_location)
+        task_report(status, task_id, "Release rebased")
+      else
+        say("Using remote release `#{release_location}'")
+        status, task_id = director.upload_remote_release(release_location)
+        task_report(status, task_id, "Release uploaded")                
+      end
+    end
+    
     def create_from_manifest(manifest_file)
       say("Recreating release from the manifest")
       Bosh::Cli::ReleaseCompiler.compile(manifest_file, release.blobstore)
@@ -279,67 +295,84 @@ module Bosh::Cli::Command
       manifest_only = !options[:with_tarball]
       dry_run = options[:dry_run]
 
-      if final && !release.has_blobstore_secret?
-        err("Can't create final release without blobstore secret")
+      err("Can't create final release without blobstore secret") if final && !release.has_blobstore_secret?
+
+      dirty_blob_check(force)
+
+      raise_dirty_state_error if dirty_state? && !force
+
+      if final
+        confirm_final_release(dry_run)
+        save_final_release_name if release.final_name.blank?
+        header("Building FINAL release".make_green)
+      else
+        save_dev_release_name if release.dev_name.blank?
+        header("Building DEV release".make_green)
       end
 
-      blob_manager.sync
-      if blob_manager.dirty?
-        blob_manager.print_status
-        if force
-          say("Proceeding with dirty blobs as '--force' is given".red)
-        else
-          err("Please use '--force' or upload new blobs")
-        end
+      if version_greater(release.min_cli_version, Bosh::Cli::VERSION)
+        err("You should use CLI >= #{release.min_cli_version} with this release, you have #{Bosh::Cli::VERSION}")
       end
 
-      check_if_dirty_state unless force
+      header("Building packages")
+      packages = build_packages(dry_run, final)
 
-      confirmation = "Are you sure you want to " +
-        "generate #{'final'.red} version? "
+      header("Building jobs")
+      jobs = build_jobs(packages.map(&:name), dry_run, final)
 
-      if final && !dry_run && !confirmed?(confirmation)
-        say("Canceled release generation".green)
-        exit(1)
-      end
+      header("Building release")
+      release_builder = build_release(dry_run, final, jobs, manifest_only, packages)
 
-      if final
-        header("Building FINAL release".green)
-        release_name = release.final_name
-      else
-        release_name = release.dev_name
-        header("Building DEV release".green)
+      header("Release summary")
+      show_summary(release_builder)
+      nl
+
+      return nil if dry_run
+
+      say("Release version: #{release_builder.version.to_s.make_green}")
+      say("Release manifest: #{release_builder.manifest_path.make_green}")
+
+      unless manifest_only
+        say("Release tarball (#{pretty_size(release_builder.tarball_path)}): " +
+                release_builder.tarball_path.make_green)
       end
 
-      if version_greater(release.min_cli_version, Bosh::Cli::VERSION)
-        err("You should use CLI >= #{release.min_cli_version} " +
-              "with this release, you have #{Bosh::Cli::VERSION}")
+      release.min_cli_version = Bosh::Cli::VERSION
+      release.save_config
+
+      release_builder.manifest_path
+    end
+
+    def confirm_final_release(dry_run)
+      confirmed = non_interactive? || agree("Are you sure you want to generate #{'final'.make_red} version? ")
+      if !dry_run && !confirmed
+        say("Canceled release generation".make_green)
+        exit(1)
       end
+    end
 
-      if release_name.blank?
-        confirmation = "Please enter %s release name: " % [
-          final ? "final" : "development"]
-        name = interactive? ? ask(confirmation).to_s : DEFAULT_RELEASE_NAME
-        err("Canceled release creation, no name given") if name.blank?
-        if final
-          release.final_name = name
+    def dirty_blob_check(force)
+      blob_manager.sync
+      if blob_manager.dirty?
+        blob_manager.print_status
+        if force
+          say("Proceeding with dirty blobs as '--force' is given".make_red)
         else
-          release.dev_name = name
+          err("Please use '--force' or upload new blobs")
         end
-        release.save_config
       end
+    end
 
-      header("Building packages")
-
+    def build_packages(dry_run, final)
       packages = Bosh::Cli::PackageBuilder.discover(
-        work_dir,
-        :final => final,
-        :blobstore => release.blobstore,
-        :dry_run => dry_run
+          work_dir,
+          :final => final,
+          :blobstore => release.blobstore,
+          :dry_run => dry_run
       )
 
       packages.each do |package|
-        say("Building #{package.name.green}...")
+        say("Building #{package.name.make_green}...")
         package.build
         nl
       end
@@ -358,52 +391,58 @@ module Bosh::Cli::Command
         nl
       end
 
-      built_package_names = packages.map { |package| package.name }
-
-      header("Building jobs")
-      jobs = Bosh::Cli::JobBuilder.discover(
-        work_dir,
-        :final => final,
-        :blobstore => release.blobstore,
-        :dry_run => dry_run,
-        :package_names => built_package_names
-      )
-
-      jobs.each do |job|
-        say("Building #{job.name.green}...")
-        job.build
-        nl
-      end
+      packages
+    end
 
-      builder = Bosh::Cli::ReleaseBuilder.new(release, packages,
-                                              jobs, :final => final)
+    def build_release(dry_run, final, jobs, manifest_only, packages)
+      release_builder = Bosh::Cli::ReleaseBuilder.new(release, packages, jobs, final: final,
+                                                      commit_hash: commit_hash, uncommitted_changes: dirty_state?)
 
       unless dry_run
         if manifest_only
-          builder.build(:generate_tarball => false)
+          release_builder.build(:generate_tarball => false)
         else
-          builder.build(:generate_tarball => true)
+          release_builder.build(:generate_tarball => true)
         end
       end
 
-      header("Release summary")
-      show_summary(builder)
-      nl
-
-      return nil if dry_run
+      release_builder
+    end
 
-      say("Release version: #{builder.version.to_s.green}")
-      say("Release manifest: #{builder.manifest_path.green}")
+    def build_jobs(built_package_names, dry_run, final)
+      jobs = Bosh::Cli::JobBuilder.discover(
+          work_dir,
+          :final => final,
+          :blobstore => release.blobstore,
+          :dry_run => dry_run,
+          :package_names => built_package_names
+      )
 
-      unless manifest_only
-        say("Release tarball (#{pretty_size(builder.tarball_path)}): " +
-              builder.tarball_path.green)
+      jobs.each do |job|
+        say("Building #{job.name.make_green}...")
+        job.build
+        nl
       end
 
-      release.min_cli_version = Bosh::Cli::VERSION
+      jobs
+    end
+
+    def save_final_release_name
+      release.final_name = DEFAULT_RELEASE_NAME
+      if interactive?
+        release.final_name = ask("Please enter final release name: ").to_s
+        err("Canceled release creation, no name given") if release.final_name.blank?
+      end
       release.save_config
+    end
 
-      builder.manifest_path
+    def save_dev_release_name
+      release.dev_name = DEFAULT_RELEASE_NAME
+      if interactive?
+        release.dev_name = ask("Please enter development release name: ").to_s
+        err("Canceled release creation, no name given") if release.dev_name.blank?
+      end
+      release.save_config
     end
 
     def git_init
@@ -432,9 +471,10 @@ module Bosh::Cli::Command
         end
       end
     rescue Errno::ENOENT
-      say("Unable to run 'git init'".red)
+      say("Unable to run 'git init'".make_red)
     end
 
+
     private
 
     # if we aren't already in a release directory, try going up two levels
@@ -503,8 +543,7 @@ module Bosh::Cli::Command
           release.has_key?("jobs") &&
           release.has_key?("packages")
         raise Bosh::Cli::DirectorError,
-              "Cannot find version, jobs and packages info " +
-              "in the director response, maybe old director?"
+              "Cannot find version, jobs and packages info in the director response, maybe old director?"
       end
 
       release
@@ -514,12 +553,76 @@ module Bosh::Cli::Command
       director.match_packages(manifest_yaml)
     rescue Bosh::Cli::DirectorError
       msg = "You are using CLI >= 0.20 with director that doesn't support " +
-        "package matches.\nThis will result in uploading all packages " +
-        "and jobs to your director.\nIt is recommended to update your " +
-        "director or downgrade your CLI to 0.19.6"
+          "package matches.\nThis will result in uploading all packages " +
+          "and jobs to your director.\nIt is recommended to update your " +
+          "director or downgrade your CLI to 0.19.6"
 
-      say(msg.yellow)
+      say(msg.make_yellow)
       exit(1) unless confirmed?
     end
+
+    def build_releases_table_for_old_director(releases)
+      table do |t|
+        t.headings = "Name", "Versions"
+        releases.each do |release|
+          versions = release["versions"].sort { |v1, v2|
+            version_cmp(v1, v2)
+          }.map { |v| ((release["in_use"] || []).include?(v)) ? "#{v}*" : v }
+
+          t << [release["name"], versions.join(", ")]
+        end
+      end
+    end
+
+    # Builds table of release information
+    # Default headings: "Name", "Versions", "Commit Hash"
+    # Extra headings: options[:job] => "Jobs"
+    def build_releases_table(releases, options = {})
+      show_jobs = options[:jobs]
+      table do |t|
+        t.headings = "Name", "Versions", "Commit Hash"
+        t.headings << "Jobs" if show_jobs
+        releases.each do |release|
+          versions, commit_hashes = formatted_versions(release).transpose
+          row = [release["name"], versions.join("\n"), commit_hashes.join("\n")]
+          if show_jobs
+            jobs = formatted_jobs(release).transpose
+            row << jobs.join("\n")
+          end
+          t << row
+        end
+      end
+    end
+
+    def formatted_versions(release)
+      sort_versions(release["release_versions"]).map { |v| formatted_version_and_commit_hash(v) }
+    end
+
+    def sort_versions(versions)
+      versions.sort { |v1, v2| version_cmp(v1["version"], v2["version"]) }
+    end
+
+    def formatted_version_and_commit_hash(version)
+      version_number = version["version"] + (version["currently_deployed"] ? "*" : "")
+      commit_hash = version["commit_hash"] + (version["uncommitted_changes"] ? "+" : "")
+      [version_number, commit_hash]
+    end
+
+    def formatted_jobs(release)
+      sort_versions(release["release_versions"]).map do |v|
+        if job_names = v["job_names"]
+          [job_names.join(", ")]
+        else
+          ["n/a  "] # with enough whitespace to match "Jobs" header
+        end
+      end
+    end
+
+    def commit_hash
+      status = Bosh::Exec.sh('git show-ref --head --hash=8 2> /dev/null')
+      status.output.split.first
+    rescue Bosh::Exec::Error => e
+      '00000000'
+    end
   end
-end
+end