class Bosh::Director::DeploymentPlan::Planner

Attributes

canonical_name[R]

@return [String] Deployment canonical name (for DNS)

cloud_planner[W]
instance_groups[R]

@return [Array<Bosh::Director::DeploymentPlan::Job>]

All instance_groups in the deployment
manifest_text[R]
model[R]

@return [Models::Deployment] Deployment DB model

name[R]

@return [String] Deployment name

properties[RW]
recreate[R]

@return [Boolean] Indicates whether VMs should be recreated

skip_drain[R]

@return [Boolean] Indicates whether VMs should be drained

stemcells[R]

Stemcells in deployment by alias

unneeded_instances[R]

Job instances from the old manifest that are not in the new manifest

update[RW]

@return [Bosh::Director::DeploymentPlan::UpdateConfig]

Default job update configuration

Public Class Methods

new(attrs, manifest_text, cloud_config, runtime_config, deployment_model, options = {}) click to toggle source
# File lib/bosh/director/deployment_plan/planner.rb, line 57
def initialize(attrs, manifest_text, cloud_config, runtime_config, deployment_model, options = {})
  @name = attrs.fetch(:name)
  @properties = attrs.fetch(:properties)
  @releases = {}

  @manifest_text = Bosh::Common::DeepCopy.copy(manifest_text)
  @cloud_config = cloud_config
  @runtime_config = runtime_config
  @model = deployment_model

  @stemcells = {}
  @instance_groups = []
  @instance_groups_name_index = {}
  @instance_groups_canonical_name_index = Set.new

  @unneeded_vms = []
  @unneeded_instances = []

  @recreate = !!options['recreate']

  @link_spec = Hash.new{ |h,k| h[k] = Hash.new(&h.default_proc) }
  @skip_drain = SkipDrain.new(options['skip_drain'])

  @logger = Config.logger
end

Public Instance Methods

add_instance_group(instance_group) click to toggle source

Adds a job by name @param [Bosh::Director::DeploymentPlan::InstanceGroup] instance_group

# File lib/bosh/director/deployment_plan/planner.rb, line 213
def add_instance_group(instance_group)
  if @instance_groups_canonical_name_index.include?(instance_group.canonical_name)
    raise DeploymentCanonicalJobNameTaken,
      "Invalid instance group name '#{instance_group.name}', canonical name already taken"
  end

  @instance_groups << instance_group
  @instance_groups_name_index[instance_group.name] = instance_group
  @instance_groups_canonical_name_index << instance_group.canonical_name
end
add_release(release) click to toggle source

Adds a release by name @param [Bosh::Director::DeploymentPlan::ReleaseVersion] release

# File lib/bosh/director/deployment_plan/planner.rb, line 181
def add_release(release)
  if @releases.has_key?(release.name)
    raise DeploymentDuplicateReleaseName,
      "Duplicate release name '#{release.name}'"
  end
  @releases[release.name] = release
end
add_stemcell(stemcell) click to toggle source
# File lib/bosh/director/deployment_plan/planner.rb, line 171
def add_stemcell(stemcell)
  @stemcells[stemcell.alias] = stemcell
end
bind_models(skip_links_binding = false) click to toggle source
# File lib/bosh/director/deployment_plan/planner.rb, line 105
def bind_models(skip_links_binding = false)
  stemcell_manager = Api::StemcellManager.new
  dns_manager = DnsManagerProvider.create
  assembler = DeploymentPlan::Assembler.new(
    self,
    stemcell_manager,
    dns_manager,
    Config.cloud,
    @logger
  )

  assembler.bind_models(skip_links_binding)
end
candidate_existing_instances() click to toggle source
# File lib/bosh/director/deployment_plan/planner.rb, line 157
def candidate_existing_instances
  desired_job_names = instance_groups.map(&:name)
  migrating_job_names = instance_groups.map(&:migrated_from).flatten.map(&:name)

  existing_instances.select do |instance|
    desired_job_names.include?(instance.job) ||
      migrating_job_names.include?(instance.job)
  end
end
compile_packages() click to toggle source
# File lib/bosh/director/deployment_plan/planner.rb, line 119
def compile_packages
  validate_packages

  cloud = Config.cloud
  vm_deleter = VmDeleter.new(cloud, @logger, false, Config.enable_virtual_delete_vms)
  disk_manager = DiskManager.new(cloud, @logger)
  job_renderer = JobRenderer.create
  arp_flusher = ArpFlusher.new
  vm_creator = Bosh::Director::VmCreator.new(cloud, @logger, vm_deleter, disk_manager, job_renderer, arp_flusher)
  dns_manager = DnsManagerProvider.create
  instance_deleter = Bosh::Director::InstanceDeleter.new(ip_provider, dns_manager, disk_manager)
  compilation_instance_pool = CompilationInstancePool.new(
    InstanceReuser.new,
    vm_creator,
    self,
    @logger,
    instance_deleter,
    compilation.workers)
  package_compile_step = DeploymentPlan::Steps::PackageCompileStep.new(
    instance_groups,
    compilation,
    compilation_instance_pool,
    @logger,
    nil
  )
  package_compile_step.perform
end
existing_instances() click to toggle source
# File lib/bosh/director/deployment_plan/planner.rb, line 153
def existing_instances
  instance_models
end
instance_group(name) click to toggle source

Returns a named instance_group @param [String] name Instance group name @return [Bosh::Director::DeploymentPlan::InstanceGroup] Instance group

# File lib/bosh/director/deployment_plan/planner.rb, line 227
def instance_group(name)
  @instance_groups_name_index[name]
end
instance_models() click to toggle source

Returns a list of Instances in the deployment (according to DB) @return [Array<Models::Instance>]

# File lib/bosh/director/deployment_plan/planner.rb, line 149
def instance_models
  @model.instances
end
instance_plans_with_missing_vms() click to toggle source
# File lib/bosh/director/deployment_plan/planner.rb, line 201
def instance_plans_with_missing_vms
  jobs_starting_on_deploy.collect_concat do |job|
    job.instance_plans_with_missing_vms
  end
end
jobs_starting_on_deploy() click to toggle source
# File lib/bosh/director/deployment_plan/planner.rb, line 231
def jobs_starting_on_deploy
  instance_groups = []

  @instance_groups.each do |instance_group|
    if instance_group.is_service?
      instance_groups << instance_group
    elsif instance_group.is_errand?
      if instance_group.instances.any? { |i| nil != i.model && !i.model.vm_cid.to_s.empty? }
        instance_groups << instance_group
      end
    end
  end

  instance_groups
end
mark_instance_for_deletion(instance) click to toggle source
# File lib/bosh/director/deployment_plan/planner.rb, line 207
def mark_instance_for_deletion(instance)
  @unneeded_instances << instance
end
persist_updates!() click to toggle source
# File lib/bosh/director/deployment_plan/planner.rb, line 247
def persist_updates!
  #prior updates may have had release versions that we no longer use.
  #remove the references to these stale releases.
  stale_release_versions = (model.release_versions - releases.map(&:model))
  stale_release_names = stale_release_versions.map {|version_model| version_model.release.name}.uniq
  with_release_locks(stale_release_names) do
    stale_release_versions.each do |release_version|
      model.remove_release_version(release_version)
    end
  end

  model.manifest = Psych.dump(@manifest_text)
  model.cloud_config = @cloud_config
  model.runtime_config = @runtime_config
  model.link_spec = @link_spec
  model.save
end
release(name) click to toggle source

Returns a named release @return [Bosh::Director::DeploymentPlan::ReleaseVersion]

# File lib/bosh/director/deployment_plan/planner.rb, line 197
def release(name)
  @releases[name]
end
releases() click to toggle source

Returns all releases in a deployment plan @return [Array<Bosh::Director::DeploymentPlan::ReleaseVersion>]

# File lib/bosh/director/deployment_plan/planner.rb, line 191
def releases
  @releases.values
end
skip_drain_for_job?(name) click to toggle source
# File lib/bosh/director/deployment_plan/planner.rb, line 167
def skip_drain_for_job?(name)
  @skip_drain.nil? ? false : @skip_drain.for_job(name)
end
stemcell(name) click to toggle source
# File lib/bosh/director/deployment_plan/planner.rb, line 175
def stemcell(name)
  @stemcells[name]
end
update_stemcell_references!() click to toggle source
# File lib/bosh/director/deployment_plan/planner.rb, line 265
def update_stemcell_references!
  current_stemcell_models = resource_pools.map { |pool| pool.stemcell.model }
  @stemcells.values.map(&:model).each do |stemcell|
    current_stemcell_models << stemcell
  end
  model.stemcells.each do |deployment_stemcell|
    deployment_stemcell.remove_deployment(model) unless current_stemcell_models.include?(deployment_stemcell)
  end
end
using_global_networking?() click to toggle source
# File lib/bosh/director/deployment_plan/planner.rb, line 275
def using_global_networking?
  !@cloud_config.nil?
end

Private Instance Methods

validate_packages() click to toggle source
# File lib/bosh/director/deployment_plan/planner.rb, line 281
def validate_packages
  release_manager = Bosh::Director::Api::ReleaseManager.new
  validator = DeploymentPlan::PackageValidator.new(@logger)
  instance_groups.each do |job|
    job.templates.each do |template|
      release_model = release_manager.find_by_name(template.release.name)
      release_version_model = release_manager.find_version(release_model, template.release.version)

      validator.validate(release_version_model, job.stemcell.model)
    end
  end
  validator.handle_faults
end