class Bosh::Director::DeploymentPlan::PlannerFactory

Public Class Methods

create(logger) click to toggle source
# File lib/bosh/director/deployment_plan/planner_factory.rb, line 15
def self.create(logger)
  deployment_manifest_migrator = Bosh::Director::DeploymentPlan::ManifestMigrator.new
  manifest_validator = Bosh::Director::DeploymentPlan::ManifestValidator.new
  deployment_repo = Bosh::Director::DeploymentPlan::DeploymentRepo.new

  new(
    deployment_manifest_migrator,
    manifest_validator,
    deployment_repo,
    logger
  )
end
new(deployment_manifest_migrator, manifest_validator, deployment_repo, logger) click to toggle source
# File lib/bosh/director/deployment_plan/planner_factory.rb, line 28
def initialize(deployment_manifest_migrator, manifest_validator, deployment_repo, logger)
  @deployment_manifest_migrator = deployment_manifest_migrator
  @manifest_validator = manifest_validator
  @deployment_repo = deployment_repo
  @logger = logger
end

Public Instance Methods

create_from_manifest(manifest, cloud_config, runtime_config, options) click to toggle source
# File lib/bosh/director/deployment_plan/planner_factory.rb, line 40
def create_from_manifest(manifest, cloud_config, runtime_config, options)
  parse_from_manifest(manifest, cloud_config, runtime_config, options)
end
create_from_model(deployment_model, options={}) click to toggle source
# File lib/bosh/director/deployment_plan/planner_factory.rb, line 35
def create_from_model(deployment_model, options={})
  manifest = Manifest.load_from_text(deployment_model.manifest, deployment_model.cloud_config, deployment_model.runtime_config)
  create_from_manifest(manifest, deployment_model.cloud_config, deployment_model.runtime_config, options)
end

Private Instance Methods

find_property(property_path, scoped_properties) click to toggle source
# File lib/bosh/director/deployment_plan/planner_factory.rb, line 194
def find_property(property_path, scoped_properties)
  current_node = scoped_properties
  property_path.each do |key|
    if !current_node || !current_node.has_key?(key)
      return {'found'=> false, 'value' => nil}
    else
      current_node = current_node[key]
    end
  end
  return {'found'=> true,'value'=> current_node}
end
get_default_properties(deployment, template) click to toggle source
# File lib/bosh/director/deployment_plan/planner_factory.rb, line 142
def get_default_properties(deployment, template)
  release_manager = Api::ReleaseManager.new

  release_versions_templates_models_hash = {}

  template_name = template.name
  release_name = template.release.name

  release = deployment.release(release_name)

  if !release_versions_templates_models_hash.has_key?(release_name)
    release_model = release_manager.find_by_name(release_name)
    current_release_version = release_manager.find_version(release_model, release.version)
    release_versions_templates_models_hash[release_name] = current_release_version.templates
  end

  templates_models_list = release_versions_templates_models_hash[release_name]
  current_template_model = templates_models_list.find {|target| target.name == template_name }

  if current_template_model.properties != nil
    default_prop = {}
    default_prop['properties'] = current_template_model.properties
    default_prop["template_name"] = template.name
    return default_prop
  end

  return {"template_name" => template.name}
end
parse_from_manifest(manifest, cloud_config, runtime_config, options) click to toggle source
# File lib/bosh/director/deployment_plan/planner_factory.rb, line 46
def parse_from_manifest(manifest, cloud_config, runtime_config, options)
  manifest.resolve_aliases
  @manifest_validator.validate(manifest.manifest_hash, manifest.cloud_config_hash)
  deployment_manifest, cloud_manifest = @deployment_manifest_migrator.migrate(manifest.manifest_hash, manifest.cloud_config_hash)
  @logger.debug("Migrated deployment manifest:\n#{deployment_manifest}")
  @logger.debug("Migrated cloud config manifest:\n#{cloud_manifest}")
  name = deployment_manifest['name']

  deployment_model = @deployment_repo.find_or_create_by_name(name, options)

  attrs = {
    name: name,
    properties: deployment_manifest.fetch('properties', {}),
  }

  plan_options = {
    'recreate' => !!options['recreate'],
    'skip_drain' => options['skip_drain'],
    'job_states' => options['job_states'] || {},
    'max_in_flight' => parse_numerical_arguments(options['max_in_flight']),
    'canaries' => parse_numerical_arguments(options['canaries'])
  }

  @logger.info('Creating deployment plan')
  @logger.info("Deployment plan options: #{plan_options}")

  deployment_planner = Planner.new(attrs, deployment_manifest, cloud_config, runtime_config, deployment_model, plan_options)
  global_network_resolver = GlobalNetworkResolver.new(deployment_planner, Config.director_ips, @logger)

  ip_provider_factory = IpProviderFactory.new(deployment_planner.using_global_networking?, @logger)
  deployment_planner.cloud_planner = CloudManifestParser.new(@logger).parse(cloud_manifest, global_network_resolver, ip_provider_factory)
  DeploymentSpecParser.new(deployment_planner, Config.event_log, @logger).parse(deployment_manifest, plan_options)

  if runtime_config
    RuntimeManifestParser.new(@logger, deployment_planner).parse(runtime_config.manifest)
  end

  process_links(deployment_planner)

  DeploymentValidator.new.validate(deployment_planner)
  deployment_planner
end
parse_numerical_arguments(arg) click to toggle source
# File lib/bosh/director/deployment_plan/planner_factory.rb, line 221
def parse_numerical_arguments arg
  case arg
    when nil
      nil
    when /%/
      raise 'percentages not yet supported for max in flight and canary cli overrides'
    when /\A[-+]?[0-9]+\z/
      arg.to_i
    else
      raise 'cannot be converted to integer'
  end
end
update_mapped_properties(mapped_properties, property_path, value) click to toggle source
# File lib/bosh/director/deployment_plan/planner_factory.rb, line 206
def update_mapped_properties(mapped_properties, property_path, value)
  current_node = mapped_properties
  property_path.each_with_index do |key, index|
    if index == property_path.size - 1
      current_node[key] = value
    else
      if !current_node.has_key?(key)
        current_node[key] = {}
      end
      current_node = current_node[key]
    end
  end
  return mapped_properties
end