Class: Bosh::Director::Api::ReleaseManager

Inherits:
Object
  • Object
show all
Includes:
ApiHelper
Defined in:
lib/bosh/director/api/release_manager.rb

Constant Summary

Constants included from ApiHelper

ApiHelper::READ_CHUNK_SIZE

Instance Method Summary collapse

Methods included from ApiHelper

#check_available_disk_space, #json_decode, #json_encode, #prepare_yml_file, #send_disposable_file, #start_task, #validate_manifest_yml, #write_file

Instance Method Details

#create_release_from_file_path(username, release_path, options) ⇒ Object 



79
80
81
82
83
84
85
 
# File 'lib/bosh/director/api/release_manager.rb', line 79

def create_release_from_file_path(username, release_path, options)
  unless File.exists?(release_path)
    raise DirectorError, "Failed to create release: file not found - #{release_path}"
  end

  JobQueue.new.enqueue(username, Jobs::UpdateRelease, 'create release', [release_path, options])
end

#create_release_from_url(username, release_url, options) ⇒ Object 



74
75
76
77
 
# File 'lib/bosh/director/api/release_manager.rb', line 74

def create_release_from_url(username, release_url, options)
  options[:remote] = true
  JobQueue.new.enqueue(username, Jobs::UpdateRelease, 'create release', [release_url, options])
end

#delete_release(username, release, options = {}) ⇒ Object 



87
88
89
 
# File 'lib/bosh/director/api/release_manager.rb', line 87

def delete_release(username, release, options = {})
  JobQueue.new.enqueue(username, Jobs::DeleteRelease, "delete release: #{release.name}", [release.name, options])
end

#export_release(username, deployment_name, release_name, release_version, stemcell_os, stemcell_version) ⇒ Object 



91
92
93
94
95
96
97
 
# File 'lib/bosh/director/api/release_manager.rb', line 91

def export_release(username, deployment_name, release_name, release_version, stemcell_os, stemcell_version)
  JobQueue.new.enqueue(
      username,
      Jobs::ExportRelease,
      "export release: '#{release_name}/#{release_version}' for '#{stemcell_os}/#{stemcell_version}'",
      [deployment_name, release_name, release_version, stemcell_os, stemcell_version])
end

#find_by_name(name) ⇒ Object 



39
40
41
42
43
44
45
 
# File 'lib/bosh/director/api/release_manager.rb', line 39

def find_by_name(name)
  release = Models::Release[:name => name]
  if release.nil?
    raise ReleaseNotFound, "Release '#{name}' doesn't exist"
  end
  release
end

#find_version(release, version) ⇒ Object 



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/bosh/director/api/release_manager.rb', line 47

def find_version(release, version)
  dataset = release.versions_dataset

  release_version = dataset.filter(:version => version).first
  if release_version.nil?
    begin
      new_formatted_version = Bosh::Common::Version::ReleaseVersion.parse(version)
    rescue SemiSemantic::ParseError
      raise ReleaseVersionInvalid, "Release version invalid: #{version}"
    end
    if version == new_formatted_version.to_s
      old_formatted_version = new_formatted_version.to_old_format
      if old_formatted_version
        release_version = dataset.filter(:version => old_formatted_version).first
      end
    else
      release_version = dataset.filter(:version => new_formatted_version.to_s).first
    end
    if release_version.nil?
      raise ReleaseVersionNotFound,
            "Release version '#{release.name}/#{version}' doesn't exist"
    end
  end

  release_version
end

#get_all_releases ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# File 'lib/bosh/director/api/release_manager.rb', line 6

def get_all_releases
  releases = Models::Release.order_by(Sequel.asc(:name)).map do |release|
    release_versions = sorted_release_versions(release)
    {
      'name' => release.name,
      'release_versions' => release_versions
    }
  end

  releases
end

#sorted_release_versions(release) ⇒ Object 



18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/bosh/director/api/release_manager.rb', line 18

def sorted_release_versions(release)
  sorted_version_tuples = release.versions_dataset.all.map do |version|
    {
      provided: version,
      parsed: Bosh::Common::Version::ReleaseVersion.parse(version.values[:version])
    }
  end.sort_by { |rv| rv[:parsed] }
  release_versions = sorted_version_tuples.map do |version|
    provided = version[:provided]
    {
      'version' => provided.version.to_s,
      'commit_hash' => provided.commit_hash,
      'uncommitted_changes' => provided.uncommitted_changes,
      'currently_deployed' => !provided.deployments.empty?,
      'job_names' => provided.templates.map(&:name),
    }
  end

  release_versions
end