bosh_cli 1.2671.0 → 1.2682.0

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

@@ -0,0 +1,27 @@
+module Bosh::Cli::Command
+  module Release
+    class ResetRelease < Base
+
+      usage 'reset release'
+      desc 'Reset dev release'
+      def reset
+        check_if_release_dir
+
+        say('Your dev release environment will be completely reset'.make_red)
+        if confirmed?
+          say('Removing dev_builds index...')
+          FileUtils.rm_rf('.dev_builds')
+          say('Clearing dev name...')
+          release.dev_name = nil
+          release.save_config
+          say('Removing dev tarballs...')
+          FileUtils.rm_rf('dev_releases')
+
+          say('Release has been reset'.make_green)
+        else
+          say('Canceled')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,208 @@
+module Bosh::Cli::Command
+  module Release
+    class UploadRelease < Base
+
+      usage '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,
+          :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')
+          end
+          unless confirmed?("Upload release `#{File.basename(release_file).make_green}' to `#{target_name.make_green}'")
+            err('Canceled upload')
+          end
+        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}'`
+
+          if file_type =~ /text\/(plain|yaml)/
+            upload_manifest(release_file, upload_options)
+          else
+            upload_tarball(release_file, upload_options)
+          end
+        end
+      end
+
+      private
+
+      def upload_manifest(manifest_path, upload_options = {})
+        package_matches = match_remote_packages(File.read(manifest_path))
+
+        find_release_dir(manifest_path)
+
+        blobstore = release.blobstore
+        tmpdir = Dir.mktmpdir
+
+        compiler = Bosh::Cli::ReleaseCompiler.new(manifest_path, blobstore, package_matches)
+        need_repack = true
+
+        unless compiler.exists?
+          compiler.tarball_path = File.join(tmpdir, 'release.tgz')
+          compiler.compile
+          need_repack = false
+        end
+
+        upload_options[:repack] = need_repack
+        upload_tarball(compiler.tarball_path, upload_options)
+      end
+
+      def upload_tarball(tarball_path, upload_options = {})
+        tarball = Bosh::Cli::ReleaseTarball.new(tarball_path)
+        # Trying to repack release by default
+        repack = upload_options[:repack]
+        rebase = upload_options[:rebase]
+
+        say("\nVerifying release...")
+        tarball.validate(:allow_sparse => true)
+        nl
+
+        unless tarball.valid?
+          err('Release is invalid, please fix, verify and upload again')
+        end
+
+        if should_convert_to_old_format?(tarball.version)
+          msg = "You are using CLI > 1.2579.0 with a director that doesn't support " +
+            'the new version format you are using. Upgrade your ' +
+            'director to match the version of your CLI or downgrade your ' +
+            'CLI to 1.2579.0 to avoid versioning mismatch issues.'
+
+          say(msg.make_yellow)
+          tarball_path = tarball.convert_to_old_format
+        end
+
+        remote_release = get_remote_release(tarball.release_name) rescue nil
+        if remote_release && !rebase
+          version = if new_director?
+                      Bosh::Common::Version::ReleaseVersion.parse(tarball.version)
+                    else
+                      tarball.version
+                    end
+          if remote_release['versions'].include?(version.to_s)
+            if upload_options[:skip_if_exists]
+              say("Release `#{tarball.release_name}/#{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'.make_green)
+            else
+              say("Release repacked (new size is #{pretty_size(repacked_path)})".make_green)
+              tarball_path = repacked_path
+            end
+          end
+        rescue Bosh::Cli::DirectorError
+          # It's OK for director to choke on getting
+          # a release info (think new releases)
+        end
+
+        if rebase
+          say("Uploading release (#{'will be rebased'.make_yellow})")
+          status, task_id = director.rebase_release(tarball_path)
+          task_report(status, task_id, 'Release rebased')
+        else
+          say("\nUploading release\n")
+          status, task_id = director.upload_release(tarball_path)
+          task_report(status, task_id, 'Release uploaded')
+        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
+
+      # if we aren't already in a release directory, try going up two levels
+      # to see if that is a release directory, and then use that as the base
+      def find_release_dir(manifest_path)
+        unless in_release_dir?
+          dir = File.expand_path('../..', manifest_path)
+          Dir.chdir(dir)
+          if in_release_dir?
+            @release = Bosh::Cli::Release.new(dir)
+          end
+        end
+
+      end
+
+      def get_remote_release(name)
+        release = director.get_release(name)
+
+        unless release.is_a?(Hash) &&
+          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?'
+        end
+
+        release
+      end
+
+      def match_remote_packages(manifest_yaml)
+        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'
+
+        say(msg.make_yellow)
+        exit(1) unless confirmed?
+      end
+
+      def should_convert_to_old_format?(version)
+        return false if new_director?
+        old_format = Bosh::Common::Version::ReleaseVersion.parse(version).to_old_format
+        old_format && version != old_format
+      end
+
+      def new_director?
+        director_version = director.get_status['version']
+        new_format_director_version = '1.2580.0'
+        Bosh::Common::Version::BoshVersion.parse(director_version) >=
+          Bosh::Common::Version::BoshVersion.parse(new_format_director_version)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Bosh::Cli::Command
+  module Release
+    class VerifyRelease < Base
+
+      # bosh verify release
+      usage 'verify release'
+      desc 'Verify release'
+      def verify(tarball_path)
+        tarball = Bosh::Cli::ReleaseTarball.new(tarball_path)
+
+        nl
+        say('Verifying release...')
+        tarball.validate
+        nl
+
+        if tarball.valid?
+          say("`#{tarball_path}' is a valid release".make_green)
+        else
+          say('Validation errors:'.make_red)
+          tarball.errors.each do |error|
+            say("- #{error}")
+          end
+          err("`#{tarball_path}' is not a valid release".make_red)
+        end
+      end
+    end
+  end
+end

data/lib/cli/packaging_helper.rb

@@ -7,13 +7,13 @@ module Bosh::Cli
     attr_accessor :dry_run
 
     def init_indices
-      @dev_index   = VersionsIndex.new(@dev_builds_dir)
-      @dev_storage = LocalVersionStorage.new(@dev_builds_dir)
+      @dev_index   = Versions::VersionsIndex.new(@dev_builds_dir)
+      @dev_storage = Versions::LocalVersionStorage.new(@dev_builds_dir)
 
-      @final_index = VersionsIndex.new(@final_builds_dir)
-      @final_storage = LocalVersionStorage.new(@final_builds_dir)
+      @final_index = Versions::VersionsIndex.new(@final_builds_dir)
+      @final_storage = Versions::LocalVersionStorage.new(@final_builds_dir)
 
-      @final_resolver = VersionFileResolver.new(@final_storage, @blobstore)
+      @final_resolver = Versions::VersionFileResolver.new(@final_storage, @blobstore)
     end
 
     def final?

data/lib/cli/release_builder.rb

@@ -2,29 +2,30 @@ module Bosh::Cli
   class ReleaseBuilder
     include Bosh::Cli::DependencyHelper
 
-    DEFAULT_RELEASE_NAME = "bosh_release"
-
-    attr_reader :release, :packages, :jobs, :version, :build_dir, :commit_hash, :uncommitted_changes
+    attr_reader :release, :packages, :jobs, :name, :version, :build_dir, :commit_hash, :uncommitted_changes
 
     # @param [Bosh::Cli::Release] release Current release
     # @param [Array<Bosh::Cli::PackageBuilder>] packages Built packages
     # @param [Array<Bosh::Cli::JobBuilder>] jobs Built jobs
     # @param [Hash] options Release build options
-    def initialize(release, packages, jobs, options = { })
+    def initialize(release, packages, jobs, name, options = { })
       @release = release
       @final = options.has_key?(:final) ? !!options[:final] : false
       @commit_hash = options.fetch(:commit_hash, '00000000')
       @uncommitted_changes = options.fetch(:uncommitted_changes, true)
       @packages = packages
       @jobs = jobs
+      @name = name
+      raise 'Release name is blank' if name.blank?
+
       @version = options.fetch(:version, nil)
 
       raise ReleaseVersionError.new('Version numbers cannot be specified for dev releases') if (@version && !@final)
 
-      @final_index = VersionsIndex.new(final_releases_dir)
-      @dev_index = VersionsIndex.new(dev_releases_dir)
+      @final_index = Versions::VersionsIndex.new(final_releases_dir)
+      @dev_index = Versions::VersionsIndex.new(dev_releases_dir)
       @index = @final ? @final_index : @dev_index
-      @release_storage = LocalVersionStorage.new(@index.storage_dir, release_name)
+      @release_storage = Versions::LocalVersionStorage.new(@index.storage_dir, @name)
 
       if @version && @release_storage.has_file?(@version)
         raise ReleaseVersionError.new('Release version already exists')
@@ -38,12 +39,6 @@ module Bosh::Cli
       end
     end
 
-    # @return [String] Release name
-    def release_name
-      name = @final ? @release.final_name : @release.dev_name
-      name.blank? ? DEFAULT_RELEASE_NAME : name
-    end
-
     # @return [String] Release version
     def version
       @version ||= assign_version.to_s
@@ -136,11 +131,10 @@ module Bosh::Cli
       manifest["commit_hash"] = commit_hash
       manifest["uncommitted_changes"] = uncommitted_changes
 
-      manifest["name"] = release_name
-
-      unless manifest["name"].bosh_valid_id?
-        raise InvalidRelease, "Release name `#{manifest["name"]}' is not a valid BOSH identifier"
+      unless @name.bosh_valid_id?
+        raise InvalidRelease, "Release name `#{@name}' is not a valid BOSH identifier"
       end
+      manifest["name"] = @name
 
       # New release versions are allowed to have the same fingerprint as old versions.
       # For reverse compatibility, random uuids are stored instead.
@@ -192,25 +186,25 @@ module Bosh::Cli
     end
 
     def final_releases_dir
-      File.join(@release.dir, "releases")
+      File.join(@release.dir, 'releases', @name)
     end
 
     def dev_releases_dir
-      File.join(@release.dir, "dev_releases")
+      File.join(@release.dir, 'dev_releases', @name)
     end
 
     def tarball_path
-      File.join(releases_dir, "#{release_name}-#{version}.tgz")
+      File.join(releases_dir, "#{@name}-#{version}.tgz")
     end
 
     def manifest_path
-      File.join(releases_dir, "#{release_name}-#{version}.yml")
+      File.join(releases_dir, "#{@name}-#{version}.yml")
     end
 
     private
 
     def assign_version
-      latest_final_version = ReleaseVersionsIndex.new(@final_index).latest_version
+      latest_final_version = Versions::ReleaseVersionsIndex.new(@final_index).latest_version
       latest_final_version ||= Bosh::Common::Version::ReleaseVersion.parse('0')
 
       if @final
@@ -218,7 +212,7 @@ module Bosh::Cli
         latest_final_version.increment_release
       else
         # Increment or Reset the post-release segment
-        dev_versions = ReleaseVersionsIndex.new(@dev_index).versions
+        dev_versions = Versions::ReleaseVersionsIndex.new(@dev_index).versions
         latest_dev_version = dev_versions.latest_with_pre_release(latest_final_version)
 
         if latest_dev_version

data/lib/cli/release_compiler.rb

@@ -94,18 +94,20 @@ module Bosh::Cli
     end
 
     def find_package(package)
-      final_package_dir = File.join(@release_dir, ".final_builds", "packages", package.name)
-      final_index = VersionsIndex.new(final_package_dir)
-      dev_package_dir = File.join(@release_dir, ".dev_builds", "packages", package.name)
-      dev_index = VersionsIndex.new(dev_package_dir)
+      name = package.name
+      final_package_dir = File.join(@release_dir, '.final_builds', 'packages', name)
+      final_index = Versions::VersionsIndex.new(final_package_dir)
+      dev_package_dir = File.join(@release_dir, '.dev_builds', 'packages', name)
+      dev_index = Versions::VersionsIndex.new(dev_package_dir)
       find_in_indices(final_index, dev_index, package, 'package')
     end
 
     def find_job(job)
-      final_jobs_dir = File.join(@release_dir, ".final_builds", "jobs", job.name)
-      final_index = VersionsIndex.new(final_jobs_dir)
-      dev_jobs_dir = File.join(@release_dir, ".dev_builds", "jobs", job.name)
-      dev_index = VersionsIndex.new(dev_jobs_dir)
+      name = job.name
+      final_jobs_dir = File.join(@release_dir, '.final_builds', 'jobs', name)
+      final_index = Versions::VersionsIndex.new(final_jobs_dir)
+      dev_jobs_dir = File.join(@release_dir, '.dev_builds', 'jobs', name)
+      dev_index = Versions::VersionsIndex.new(dev_jobs_dir)
       find_in_indices(final_index, dev_index, job, 'job')
     end
 
@@ -133,9 +135,9 @@ module Bosh::Cli
       sha1 = found_build["sha1"]
       blobstore_id = found_build["blobstore_id"]
 
-      storage = LocalVersionStorage.new(index.storage_dir)
+      storage = Versions::LocalVersionStorage.new(index.storage_dir)
 
-      resolver = VersionFileResolver.new(storage, @blobstore)
+      resolver = Versions::VersionFileResolver.new(storage, @blobstore)
       resolver.find_file(blobstore_id, sha1, version, "#{build_type} #{desc}")
     rescue Bosh::Blobstore::BlobstoreError => e
       raise BlobstoreError, "Blobstore error: #{e}"

data/lib/cli/source_control/git_ignore.rb

@@ -0,0 +1,42 @@
+module Bosh::Cli::SourceControl
+  class GitIgnore
+
+    RELEASE_IGNORE_PATTERNS = [
+      'config/dev.yml',
+      'config/private.yml',
+      'releases/*.tgz',
+      'releases/**/*.tgz',
+      'dev_releases',
+      '.blobs',
+      'blobs',
+      '.dev_builds',
+      '.idea',
+      '.DS_Store',
+      '.final_builds/jobs/**/*.tgz',
+      '.final_builds/packages/**/*.tgz',
+      '*.swp',
+      '*~',
+      '*#',
+      '#*',
+    ]
+
+    def initialize(dir)
+      @dir = dir
+    end
+
+    def update
+      file_path = File.join(@dir, '.gitignore')
+
+      found_patterns = []
+      if File.exist?(file_path)
+        File.open(file_path, 'r').each_line { |line| found_patterns << line.chomp }
+      end
+
+      File.open(file_path, 'a') do |f|
+        RELEASE_IGNORE_PATTERNS.each do |pattern|
+          f.print(pattern + "\n") unless found_patterns.include?(pattern)
+        end
+      end
+    end
+  end
+end