class Bosh::Cli::ReleaseCompiler

Compiles release tarball based on manifest

Attributes

tarball_path[W]

Public Class Methods

compile(manifest_file, artifacts_dir, blobstore, package_matches, release_source) click to toggle source
# File lib/cli/release_compiler.rb, line 9
def self.compile(manifest_file, artifacts_dir, blobstore, package_matches, release_source)
  new(manifest_file, artifacts_dir, blobstore, package_matches, release_source).compile
end
new(manifest_file, artifacts_dir, blobstore, package_matches, release_source) click to toggle source

@param [String] manifest_file Release manifest path @param [Bosh::Blobstore::Client] blobstore Blobstore client @param [Array] package_matches List of package checksums that director

can match

@param [String] release_source Release directory

# File lib/cli/release_compiler.rb, line 18
def initialize(manifest_file, artifacts_dir, blobstore, package_matches, release_source)
  @blobstore = blobstore
  @release_source = release_source
  @manifest_path = File.expand_path(manifest_file, @release_source)
  @tarball_path = nil

  @artifacts_dir = artifacts_dir
  @build_dir = Dir.mktmpdir
  @jobs_dir = File.join(@build_dir, "jobs")
  @packages_dir = File.join(@build_dir, "packages")

  @package_matches = Set.new(package_matches)

  FileUtils.mkdir_p(@jobs_dir)
  FileUtils.mkdir_p(@packages_dir)

  @manifest = load_yaml_file(manifest_file)

  @name = @manifest["name"]
  @version = @manifest["version"]
  @packages = @manifest.fetch("packages", []).map { |pkg| OpenStruct.new(pkg) }
  @jobs = @manifest.fetch("jobs", []).map { |job| OpenStruct.new(job) }
  @license = @manifest["license"] ? OpenStruct.new(@manifest["license"]) : nil
end

Public Instance Methods

artifact_from(resource, type) click to toggle source
# File lib/cli/release_compiler.rb, line 43
def artifact_from(resource, type)
  return nil unless resource
  BuildArtifact.new(resource.name, resource.fingerprint, send(:"find_#{type}", resource), resource.sha1, [], nil, nil)
end
compile() click to toggle source
# File lib/cli/release_compiler.rb, line 48
def compile
  if exists?
    quit("You already have this version in '#{tarball_path.make_green}'")
  end

  packages = @packages
    .reject { |package| remote_package_exists?(package) }
    .map { |package| artifact_from(package, :package) }
  jobs = @jobs
    .reject { |job| remote_job_exists?(job) }
    .map { |job| artifact_from(job, :job) }
  license = artifact_from(@license, :license)

  archiver = ReleaseArchiver.new(tarball_path, @manifest_path, packages, jobs, license)
  archiver.build
end
exists?() click to toggle source
# File lib/cli/release_compiler.rb, line 65
def exists?
  File.exists?(tarball_path)
end
find_in_indices(final_index, dev_index, build, build_type) click to toggle source
# File lib/cli/release_compiler.rb, line 104
def find_in_indices(final_index, dev_index, build, build_type)
  desc = "#{build.name} (#{build.version})"

  index = final_index
  found_build = find_version_by_sha1(index, build.sha1)

  if found_build.nil?
    index = dev_index
    found_build = find_version_by_sha1(index, build.sha1)
  end

  if found_build.nil?
    say("MISSING".make_red)
    err("Cannot find #{build_type} with checksum '#{build.sha1}'")
  end

  sha1 = found_build["sha1"]
  blobstore_id = found_build["blobstore_id"]

  storage = Versions::LocalArtifactStorage.new(@artifacts_dir)

  resolver = Versions::VersionFileResolver.new(storage, @blobstore)
  resolver.find_file(blobstore_id, sha1, "#{build_type} #{desc}")
rescue Bosh::Blobstore::BlobstoreError => e
  raise BlobstoreError, "Blobstore error: #{e}"
end
find_job(job) click to toggle source
# File lib/cli/release_compiler.rb, line 83
def find_job(job)
  name = job.name
  final_jobs_dir = File.join(@release_source, '.final_builds', 'jobs', name)
  final_index = Versions::VersionsIndex.new(final_jobs_dir)
  dev_jobs_dir = File.join(@release_source, '.dev_builds', 'jobs', name)
  dev_index = Versions::VersionsIndex.new(dev_jobs_dir)
  find_in_indices(final_index, dev_index, job, 'job')
end
find_license(license) click to toggle source
# File lib/cli/release_compiler.rb, line 92
def find_license(license)
  final_dir = File.join(@release_source, '.final_builds', 'license')
  final_index = Versions::VersionsIndex.new(final_dir)
  dev_dir = File.join(@release_source, '.dev_builds', 'license')
  dev_index = Versions::VersionsIndex.new(dev_dir)
  find_in_indices(final_index, dev_index, license, 'license')
end
find_package(package) click to toggle source
# File lib/cli/release_compiler.rb, line 74
def find_package(package)
  name = package.name
  final_package_dir = File.join(@release_source, '.final_builds', 'packages', name)
  final_index = Versions::VersionsIndex.new(final_package_dir)
  dev_package_dir = File.join(@release_source, '.dev_builds', 'packages', name)
  dev_index = Versions::VersionsIndex.new(dev_package_dir)
  find_in_indices(final_index, dev_index, package, 'package')
end
find_version_by_sha1(index, sha1) click to toggle source
# File lib/cli/release_compiler.rb, line 100
def find_version_by_sha1(index, sha1)
  index.select{ |_, build| build['sha1'] == sha1 }.values.first
end
remote_job_exists?(local_job) click to toggle source

Checks if local job is already known remotely @param [#name, version] local_job @return [Boolean]

# File lib/cli/release_compiler.rb, line 144
def remote_job_exists?(local_job)
  false
end
remote_package_exists?(local_package) click to toggle source

Checks if local package is already known remotely @param [#name, version] local_package @return [Boolean]

# File lib/cli/release_compiler.rb, line 134
def remote_package_exists?(local_package)
  # If checksum is known to director we can always match it
  @package_matches.include?(local_package.sha1) ||                     # !!! Needs test coverage
    (local_package.fingerprint &&                                      # !!! Needs test coverage
     @package_matches.include?(local_package.fingerprint))             # !!! Needs test coverage
end
tarball_path() click to toggle source
# File lib/cli/release_compiler.rb, line 69
def tarball_path
  @tarball_path || File.join(File.dirname(@manifest_path),
                             "#{@name}-#{@version}.tgz")
end