bosh_cli 1.2671.0 → 1.2682.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4c1e1cbf0d51f7f8c6474986297c23727e40717
-  data.tar.gz: 9cba9a5e26641af58639cfb67c686e5827ce04f7
+  metadata.gz: 6c465feaf450a9d1578bdcb091559697af1ca32d
+  data.tar.gz: 32eaf038e07206d75d5b13f604908df2d37eeac5
 SHA512:
-  metadata.gz: ba53edc2f056dc17be341c9252cba7ae3d9cb6f42b7b08ed3726ec8e6b435aaddd298ba0ba2f8fb9a3b553e93cb7cf0ae832dd2d597257b9b13b9d16ace7bb70
-  data.tar.gz: ca3d07521f5537aa40cbc7379e134f69b5bada1565de8ff09dd6636f324c3671bbba796783dbe4a0ca2400d7685c705c101194c4175ae45120e6dd61d545ac0c
+  metadata.gz: 59097f2f31a97d3103137d366fd750e413bbbd19d98aa000afcc54f0e75b08a0fb4c4674157214afde9a21a4707b9948385769ad24ac3ff90b316a173f704d2c
+  data.tar.gz: f1aa9306cdae45a81eefc22b6222f9e4651be01c7238a14dc4743985bc55f98f123b8f1336d103c3f015c3f11c07b0b836abb7d6fe4e85ad53cbf3be45d54696

data/lib/cli.rb

@@ -31,6 +31,8 @@ require 'zlib'
 require 'archive/tar/minitar'
 include Archive::Tar
 
+require 'semi_semantic/version'
+
 require 'bosh/template/evaluation_context'
 
 unless defined?(Bosh::Cli::VERSION)
@@ -61,10 +63,15 @@ require 'cli/director_task'
 require 'cli/line_wrap'
 require 'cli/backup_destination_path'
 
+require 'cli/source_control/git_ignore'
+
 require 'cli/versions/versions_index'
 require 'cli/versions/local_version_storage'
 require 'cli/versions/release_versions_index'
+require 'cli/versions/releases_dir_migrator'
 require 'cli/versions/version_file_resolver'
+require 'cli/versions/multi_release_support'
+
 require 'cli/packaging_helper'
 require 'cli/package_builder'
 require 'cli/job_builder'
@@ -93,6 +100,6 @@ tmpdir = Dir.mktmpdir
 at_exit { FileUtils.rm_rf(tmpdir) }
 ENV['TMPDIR'] = tmpdir
 
-Dir[File.dirname(__FILE__) + '/cli/commands/*.rb'].each do |file|
+Dir[File.dirname(__FILE__) + '/cli/commands/**/*.rb'].each do |file|
   require file
 end

data/lib/cli/commands/release/create_release.rb

@@ -0,0 +1,279 @@
+module Bosh::Cli::Command
+  module Release
+    class CreateRelease < Base
+      include Bosh::Cli::DependencyHelper
+
+      DEFAULT_RELEASE_NAME = 'bosh-release'
+
+      # bosh create release
+      usage 'create release'
+      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'
+      option '--dry-run', 'stop before writing release manifest'
+      option '--name NAME', 'specify a custom release name'
+      option '--version VERSION', 'specify a custom version number (ex: 1.0.0 or 1.0-beta.2+dev.10)'
+
+      def create(manifest_file = nil)
+        check_if_release_dir
+
+        migrate_to_support_multiple_releases
+
+        if manifest_file && File.file?(manifest_file)
+          if options[:version]
+            err('Cannot specify a custom version number when creating from a manifest. The manifest already specifies a version.'.make_red)
+          end
+
+          say('Recreating release from the manifest')
+          Bosh::Cli::ReleaseCompiler.compile(manifest_file, release.blobstore)
+          release_filename = manifest_file
+        else
+          version = options[:version]
+          version = Bosh::Common::Version::ReleaseVersion.parse(version).to_s unless version.nil?
+
+          release_filename = create_from_spec(version)
+        end
+
+        if release_filename
+          release.latest_release_filename = release_filename
+          release.save_config
+        end
+      rescue SemiSemantic::ParseError
+        err("Invalid version: `#{version}'. Please specify a valid version (ex: 1.0.0 or 1.0-beta.2+dev.10).".make_red)
+      rescue Bosh::Cli::ReleaseVersionError => e
+        err(e.message.make_red)
+      end
+
+      private
+
+      def migrate_to_support_multiple_releases
+        default_release_name = release.final_name
+
+        # can't migrate without a default release name
+        return if default_release_name.blank?
+
+        Bosh::Cli::Versions::MultiReleaseSupport.new(@work_dir, default_release_name, self).migrate
+      end
+
+      def create_from_spec(version)
+        final = options[:final]
+        force = options[:force]
+        name = options[:name]
+        manifest_only = !options[:with_tarball]
+        dry_run = options[:dry_run]
+
+        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)
+          unless name
+            save_final_release_name if release.final_name.blank?
+            name = release.final_name
+          end
+          header('Building FINAL release'.make_green)
+        else
+          unless name
+            save_dev_release_name if release.dev_name.blank?
+            name = release.dev_name
+          end
+          header('Building DEV release'.make_green)
+        end
+
+        header('Building packages')
+        packages = build_packages(dry_run, final)
+
+        header('Building jobs')
+        jobs = build_jobs(packages.map(&:name), dry_run, final)
+
+        header('Building release')
+        release_builder = build_release(dry_run, final, jobs, manifest_only, packages, name, version)
+
+        header('Release summary')
+        show_summary(release_builder)
+        nl
+
+        return nil if dry_run
+
+        say("Release name: #{name.make_green}")
+        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
+
+        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
+
+      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
+            err("Please use '--force' or upload new blobs")
+          end
+        end
+      end
+
+      def build_packages(dry_run, final)
+        packages = Bosh::Cli::PackageBuilder.discover(
+          work_dir,
+          :final => final,
+          :blobstore => release.blobstore,
+          :dry_run => dry_run
+        )
+
+        packages.each do |package|
+          say("Building #{package.name.make_green}...")
+          package.build
+          nl
+        end
+
+        if packages.size > 0
+          package_index = packages.inject({}) do |index, package|
+            index[package.name] = package.dependencies
+            index
+          end
+          sorted_packages = tsort_packages(package_index)
+          header('Resolving dependencies')
+          say('Dependencies resolved, correct build order is:')
+          sorted_packages.each do |package_name|
+            say('- %s' % [package_name])
+          end
+          nl
+        end
+
+        packages
+      end
+
+      def build_release(dry_run, final, jobs, manifest_only, packages, name, version)
+        release_builder = Bosh::Cli::ReleaseBuilder.new(release, packages, jobs, name,
+          final: final,
+          commit_hash: commit_hash,
+          version: version,
+          uncommitted_changes: dirty_state?
+        )
+
+        unless dry_run
+          if manifest_only
+            release_builder.build(:generate_tarball => false)
+          else
+            release_builder.build(:generate_tarball => true)
+          end
+        end
+
+        release_builder
+      end
+
+      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
+        )
+
+        jobs.each do |job|
+          say("Building #{job.name.make_green}...")
+          job.build
+          nl
+        end
+
+        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
+
+      def save_dev_release_name
+        if interactive?
+          release.dev_name = ask('Please enter development release name: ') do |q|
+            q.default = release.final_name if release.final_name
+          end.to_s
+          err('Canceled release creation, no name given') if release.dev_name.blank?
+        else
+          release.dev_name = release.final_name ? release.final_name : DEFAULT_RELEASE_NAME
+        end
+        release.save_config
+      end
+
+      def show_summary(builder)
+        packages_table = table do |t|
+          t.headings = %w(Name Version Notes)
+          builder.packages.each do |package|
+            t << artifact_summary(package)
+          end
+        end
+
+        jobs_table = table do |t|
+          t.headings = %w(Name Version Notes)
+          builder.jobs.each do |job|
+            t << artifact_summary(job)
+          end
+        end
+
+        say('Packages')
+        say(packages_table)
+        nl
+        say('Jobs')
+        say(jobs_table)
+
+        affected_jobs = builder.affected_jobs
+
+        if affected_jobs.size > 0
+          nl
+          say('Jobs affected by changes in this release')
+
+          affected_jobs_table = table do |t|
+            t.headings = %w(Name Version)
+            affected_jobs.each do |job|
+              t << [job.name, job.version]
+            end
+          end
+
+          say(affected_jobs_table)
+        end
+      end
+
+      def artifact_summary(artefact)
+        result = []
+        result << artefact.name
+        result << artefact.version
+        result << artefact.notes.join(', ')
+        result
+      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
+        '00000000'
+      end
+    end
+  end
+end

data/lib/cli/commands/release/delete_release.rb

@@ -0,0 +1,32 @@
+module Bosh::Cli::Command
+  module Release
+    class DeleteRelease < Base
+
+      usage 'delete release'
+      desc 'Delete release (or a particular release version)'
+      option '--force', 'ignore errors during deletion'
+      def delete(name, version = nil)
+        auth_required
+        force = !!options[:force]
+
+        desc = "#{name}"
+        desc << "/#{version}" if version
+
+        if force
+          say("Deleting `#{desc}' (FORCED DELETE, WILL IGNORE ERRORS)".make_red)
+        else
+          say("Deleting `#{desc}'".make_red)
+        end
+
+        if confirmed?
+          status, task_id = director.delete_release(name, force: force, version: version)
+          task_report(status, task_id, "Deleted `#{desc}'")
+        else
+          say('Canceled deleting release'.make_green)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/cli/commands/release/init_release.rb

@@ -0,0 +1,45 @@
+module Bosh::Cli::Command
+  module Release
+    class InitRelease < Base
+
+      # bosh init release
+      usage 'init release'
+      desc 'Initialize release directory'
+      option '--git', 'initialize git repository'
+      def init(base = nil)
+        if base
+          FileUtils.mkdir_p(base)
+          Dir.chdir(base)
+        end
+
+        err('Release already initialized') if in_release_dir?
+        git_init if options[:git]
+
+        %w[config jobs packages src blobs].each do |dir|
+          FileUtils.mkdir(dir)
+        end
+
+        # Initialize an empty blobs index
+        File.open(File.join('config', 'blobs.yml'), 'w') do |f|
+          Psych.dump({}, f)
+        end
+
+        say('Release directory initialized'.make_green)
+      end
+
+      private
+
+      def git_init
+        out = %x{git init 2>&1}
+        if $? != 0
+          say("error running 'git init':\n#{out}")
+        else
+          Bosh::Cli::SourceControl::GitIgnore.new(@work_dir).update
+        end
+      rescue Errno::ENOENT
+        say("Unable to run 'git init'".make_red)
+      end
+
+    end
+  end
+end

data/lib/cli/commands/release/list_releases.rb

@@ -0,0 +1,123 @@
+module Bosh::Cli::Command
+  module Release
+    class ListReleases < Base
+
+      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|
+          r1['name'] <=> r2['name']
+        end
+
+        err('No releases') if releases.empty?
+
+        currently_deployed = false
+        uncommited_changes = false
+        if releases.first.has_key? 'release_versions'
+          releases_table = build_releases_table(releases, options)
+          currently_deployed, uncommited_changes = release_version_details(releases)
+        elsif releases.first.has_key? 'versions'
+          releases_table = build_releases_table_for_old_director(releases)
+          currently_deployed, uncommited_changes = release_version_details_for_old_director(releases)
+        end
+
+        nl
+        say(releases_table.render)
+
+        say('(*) Currently deployed') if currently_deployed
+        say('(+) Uncommitted changes') if uncommited_changes
+        nl
+        say('Releases total: %d' % releases.size)
+      end
+
+      private
+      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|
+              Bosh::Common::Version::ReleaseVersion.parse_and_compare(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| Bosh::Common::Version::ReleaseVersion.parse_and_compare(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 release_version_details(releases)
+        currently_deployed = false
+        uncommitted_changes = false
+        releases.each do |release|
+          release['release_versions'].each do |version|
+            currently_deployed ||= version['currently_deployed']
+            uncommitted_changes ||= version['uncommitted_changes']
+            if currently_deployed && uncommitted_changes
+              return true, true
+            end
+          end
+        end
+        return currently_deployed, uncommitted_changes
+      end
+
+      def release_version_details_for_old_director(releases)
+        currently_deployed = false
+        # old director did not support uncommitted changes
+        uncommitted_changes = false
+        releases.each do |release|
+          currently_deployed ||= release['in_use'].any?
+          if currently_deployed
+            return true, uncommitted_changes
+          end
+        end
+        return currently_deployed, uncommitted_changes
+      end
+    end
+  end
+end