bosh-director 1.3160.0 → 1.3163.0

data/lib/bosh/director/deployment_plan/instance_plan_sorter.rb

@@ -0,0 +1,61 @@
+module Bosh::Director::DeploymentPlan
+  class InstancePlanSorter
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def sort(instance_plans)
+      return [] if instance_plans.empty?
+
+      @logger.debug('Sorting instance plan to update them always in the same order')
+
+      @sorted_instance_plans = []
+      bootstrap_instance_plan = instance_plans.find { |instance_plan| instance_plan.instance.bootstrap? }
+      @sorted_instance_plans << bootstrap_instance_plan
+
+      bootstrap_az = bootstrap_instance_plan.instance.availability_zone_name
+      remaining_instance_plans = instance_plans - [bootstrap_instance_plan]
+
+      sorted_instance_plans_for_bootstrap_az = sorted_instance_plans_in_special_az(bootstrap_az, remaining_instance_plans)
+      remaining_instance_plans = remaining_instance_plans - sorted_instance_plans_for_bootstrap_az
+
+      sorted_instance_plans_for_no_az = sorted_instance_plans_in_special_az(nil, remaining_instance_plans)
+      remaining_instance_plans = remaining_instance_plans - sorted_instance_plans_for_no_az
+
+      instance_plans_sorted_by_az = remaining_instance_plans.sort do |plan1, plan2|
+        plan1.instance.availability_zone_name <=> plan2.instance.availability_zone_name
+      end
+
+      current_az = instance_plans_sorted_by_az.first.instance.availability_zone_name if instance_plans_sorted_by_az.any?
+      instance_plans_in_current_az = []
+      instance_plans_sorted_by_az.each do |instance_plan|
+        if instance_plan.instance.availability_zone_name == current_az
+          instance_plans_in_current_az << instance_plan
+        else
+          @sorted_instance_plans << sort_in_az(instance_plans_in_current_az)
+          current_az = instance_plan.instance.availability_zone_name
+          instance_plans_in_current_az = [instance_plan]
+        end
+      end
+      @sorted_instance_plans << sort_in_az(instance_plans_in_current_az)
+      @sorted_instance_plans.flatten
+    end
+
+    private
+    def sort_in_az(instance_plans)
+      instance_plans.sort { |plan1, plan2|
+        "#{plan1.instance.job_name}/#{plan1.instance.uuid}" <=> "#{plan2.instance.job_name}/#{plan2.instance.uuid}"
+      }
+    end
+
+    def sorted_instance_plans_in_special_az(az, instance_plans)
+      all_instance_plans_for_az = instance_plans
+                                    .select do |instance_plan|
+        instance_plan.instance.availability_zone_name == az
+      end
+      sorted_instances_for_az = sort_in_az(all_instance_plans_for_az)
+      @sorted_instance_plans << sorted_instances_for_az
+      sorted_instances_for_az
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/instance_planner.rb

@@ -0,0 +1,101 @@
+module Bosh
+  module Director
+    module DeploymentPlan
+      class InstancePlanner
+        def initialize(instance_plan_factory, logger)
+          @instance_plan_factory = instance_plan_factory
+          @logger = logger
+        end
+
+        def plan_job_instances(job, desired_instances, existing_instance_models)
+          network_planner = NetworkPlanner::Planner.new(@logger)
+          placement_plan = PlacementPlanner::Plan.new(@instance_plan_factory, network_planner, @logger)
+          vip_networks, non_vip_networks = job.networks.to_a.partition(&:vip?)
+          instance_plans = placement_plan.create_instance_plans(desired_instances, existing_instance_models, non_vip_networks, job.availability_zones, job.name)
+
+          log_outcome(instance_plans)
+
+          desired_instance_plans = instance_plans.reject(&:obsolete?)
+          vip_static_ips_planner = NetworkPlanner::VipStaticIpsPlanner.new(network_planner, @logger)
+          vip_static_ips_planner.add_vip_network_plans(desired_instance_plans, vip_networks)
+          reconcile_network_plans(desired_instance_plans)
+
+          elect_bootstrap_instance(desired_instance_plans)
+
+          instance_plans
+        end
+
+        def plan_obsolete_jobs(desired_jobs, existing_instances)
+          desired_job_names = Set.new(desired_jobs.map(&:name))
+          migrating_job_names = Set.new(desired_jobs.map(&:migrated_from).flatten.map(&:name))
+          existing_instances.reject do |existing_instance_model|
+            desired_job_names.include?(existing_instance_model.job) ||
+            migrating_job_names.include?(existing_instance_model.job)
+          end.map do |existing_instance|
+            @instance_plan_factory.obsolete_instance_plan(existing_instance)
+          end
+        end
+
+        private
+
+        def elect_bootstrap_instance(desired_instance_plans)
+          bootstrap_instance_plans = desired_instance_plans.select { |i| i.instance.bootstrap? }
+
+          if bootstrap_instance_plans.size == 1
+            bootstrap_instance_plan = bootstrap_instance_plans.first
+
+            instance = bootstrap_instance_plan.instance
+            @logger.info("Found existing bootstrap instance '#{instance}' in az '#{bootstrap_instance_plan.desired_instance.availability_zone}'")
+          else
+            return if desired_instance_plans.empty?
+
+            if bootstrap_instance_plans.size > 1
+              @logger.info('Found multiple existing bootstrap instances. Going to pick a new bootstrap instance.')
+            else
+              @logger.info('No existing bootstrap instance. Going to pick a new bootstrap instance.')
+            end
+            lowest_indexed_desired_instance_plan = desired_instance_plans
+                                                     .reject { |instance_plan| instance_plan.desired_instance.index.nil? }
+                                                     .sort_by { |instance_plan| instance_plan.desired_instance.index }
+                                                     .first
+
+            desired_instance_plans.each do |instance_plan|
+              instance = instance_plan.instance
+              if instance_plan == lowest_indexed_desired_instance_plan
+                @logger.info("Marking new bootstrap instance '#{instance}' in az '#{instance_plan.desired_instance.availability_zone}'")
+                instance.mark_as_bootstrap
+              else
+                instance.unmark_as_bootstrap
+              end
+            end
+          end
+        end
+
+        def reconcile_network_plans(instance_plans)
+          instance_plans.each do |instance_plan|
+            network_plans = NetworkPlanner::ReservationReconciler.new(instance_plan, @logger)
+                              .reconcile(instance_plan.instance.existing_network_reservations)
+            instance_plan.network_plans = network_plans
+          end
+        end
+
+        def log_outcome(instance_plans)
+          instance_plans.select(&:new?).each do |instance_plan|
+            instance = instance_plan.desired_instance
+            @logger.info("New desired instance '#{instance.job.name}/#{instance.index}' in az '#{instance.availability_zone}'")
+          end
+
+          instance_plans.select(&:existing?).each do |instance_plan|
+            instance = instance_plan.existing_instance
+            @logger.info("Existing desired instance '#{instance.job}/#{instance.index}' in az '#{instance_plan.desired_instance.availability_zone}'")
+          end
+
+          instance_plans.select(&:obsolete?).each do |instance_plan|
+            instance = instance_plan.existing_instance
+            @logger.info("Obsolete instance '#{instance.job}/#{instance.index}' in az '#{instance.availability_zone}'")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/instance_repository.rb

@@ -0,0 +1,36 @@
+module Bosh::Director::DeploymentPlan
+  class InstanceRepository
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def fetch_existing(desired_instance, existing_instance_model, existing_instance_state)
+      @logger.debug("Fetching existing instance for: #{existing_instance_model.inspect}")
+      # if state was not specified in manifest, use saved state
+      job_state = desired_instance.job.state_for_instance(existing_instance_model) || existing_instance_model.state
+      @logger.debug("Job instance states: #{desired_instance.job.instance_states}, found: #{desired_instance.job.state_for_instance(existing_instance_model)}, state: #{job_state}")
+
+      instance = Instance.create_from_job(desired_instance.job, desired_instance.index, job_state, desired_instance.deployment.model, existing_instance_state, existing_instance_model.availability_zone, @logger)
+      instance.bind_existing_instance_model(existing_instance_model)
+
+      if existing_instance_model.ip_addresses.any?
+        existing_network_reservations = InstanceNetworkReservations.create_from_db(instance, desired_instance.deployment, @logger)
+      elsif existing_instance_state
+        # This is for backwards compatibility when we did not store
+        # network reservations in DB and constructed them from instance state
+        existing_network_reservations = InstanceNetworkReservations.create_from_state(instance, existing_instance_state, desired_instance.deployment, @logger)
+      else
+        existing_network_reservations = InstanceNetworkReservations.new(@logger)
+      end
+      instance.bind_existing_reservations(existing_network_reservations)
+      instance
+    end
+
+    def create(desired_instance, index)
+      @logger.debug("Creating new desired instance for: #{desired_instance.inspect}")
+      instance = Instance.create_from_job(desired_instance.job, index, 'started', desired_instance.deployment.model, nil, desired_instance.az, @logger)
+      instance.bind_new_instance_model
+      instance
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/instance_spec.rb

@@ -0,0 +1,154 @@
+module Bosh::Director
+  module DeploymentPlan
+    class InstanceSpec
+      def self.create_empty
+        EmptyInstanceSpec.new
+      end
+
+      def self.create_from_database(spec, instance)
+        new(spec, instance)
+      end
+
+      def self.create_from_instance_plan(instance_plan)
+        instance = instance_plan.instance
+        deployment_name = instance.deployment_model.name
+        job = instance_plan.desired_instance.job
+        instance_plan = instance_plan
+        dns_manager = DnsManager.create
+
+        spec = {
+          'deployment' => deployment_name,
+          'job' => job.spec,
+          'index' => instance.index,
+          'bootstrap' => instance.bootstrap?,
+          'id' => instance.uuid,
+          'az' => instance.availability_zone_name,
+          'networks' => instance_plan.network_settings_hash,
+          'vm_type' => job.vm_type.spec,
+          'stemcell' => job.stemcell.spec,
+          'env' => job.env.spec,
+          'packages' => job.package_spec,
+          'properties' => job.properties,
+          'dns_domain_name' => dns_manager.dns_domain_name,
+          'links' => job.link_spec,
+        }
+
+        if job.persistent_disk_type
+          # supply both for reverse compatibility with old agent
+          spec['persistent_disk'] = job.persistent_disk_type.disk_size
+          # old agents will ignore this pool
+          # keep disk pool for backwards compatibility
+          spec['persistent_disk_pool'] = job.persistent_disk_type.spec
+          spec['persistent_disk_type'] = job.persistent_disk_type.spec
+        else
+          spec['persistent_disk'] = 0
+        end
+
+        new(spec, instance)
+      end
+
+      def initialize(full_spec, instance)
+        @full_spec = full_spec
+        @instance = instance
+      end
+
+      def as_template_spec
+        TemplateSpec.new(full_spec).spec
+      end
+
+      def as_apply_spec
+        ApplySpec.new(full_spec).spec
+      end
+
+      def full_spec
+        # re-generate spec with rendered templates info
+        # since job renderer sets it directly on instance
+        spec = @full_spec
+
+        if @instance.template_hashes
+          spec['template_hashes'] = @instance.template_hashes
+        end
+
+        if @instance.rendered_templates_archive
+          spec['rendered_templates_archive'] = @instance.rendered_templates_archive.spec
+        end
+
+        if @instance.configuration_hash
+          spec['configuration_hash'] = @instance.configuration_hash
+        end
+
+        spec
+      end
+    end
+
+    private
+
+    class EmptyInstanceSpec < InstanceSpec
+      def initialize
+      end
+
+      def full_spec
+        {}
+      end
+    end
+
+    class TemplateSpec
+      def initialize(full_spec)
+        @full_spec = full_spec
+        @dns_manager = DnsManager.create
+      end
+
+      def spec
+        keys = [
+          'deployment',
+          'job',
+          'index',
+          'bootstrap',
+          'id',
+          'az',
+          'networks',
+          'packages',
+          'properties',
+          'dns_domain_name',
+          'links',
+          'persistent_disk'
+        ]
+        template_hash = @full_spec.select {|k,v| keys.include?(k) }
+
+        networks_hash = template_hash['networks']
+        networks_hash_with_dns = networks_hash.each_pair do |network_name, network_settings|
+          settings_with_dns = network_settings.merge({'dns_record_name' => @dns_manager.dns_record_name(@full_spec['index'], @full_spec['job']['name'], network_name, @full_spec['deployment'])})
+          networks_hash[network_name] = settings_with_dns
+        end
+
+        template_hash.merge({
+        'resource_pool' => @full_spec['vm_type']['name'],
+        'networks' => networks_hash_with_dns
+        })
+      end
+    end
+
+    class ApplySpec
+      def initialize(full_spec)
+        @full_spec = full_spec
+      end
+
+      def spec
+        keys = [
+          'deployment',
+          'job',
+          'index',
+          'id',
+          'networks',
+          'packages',
+          'dns_domain_name',
+          'configuration_hash',
+          'persistent_disk',
+          'template_hashes',
+          'rendered_templates_archive',
+        ]
+        @full_spec.select {|k,_| keys.include?(k) }
+      end
+    end
+  end
+end

data/lib/bosh/director/deployment_plan/ip_provider/database_ip_repo.rb

@@ -0,0 +1,136 @@
+module Bosh::Director::DeploymentPlan
+  class DatabaseIpRepo
+    include Bosh::Director::IpUtil
+    class IpFoundInDatabaseAndCanBeRetried < StandardError; end
+    class NoMoreIPsAvailableAndStopRetrying < StandardError; end
+
+    def initialize(logger)
+      @logger = Bosh::Director::TaggedLogger.new(logger, 'network-configuration')
+    end
+
+    def delete(ip, _)
+      cidr_ip = CIDRIP.new(ip)
+
+      ip_address = Bosh::Director::Models::IpAddress.first(address: cidr_ip.to_i)
+
+      if ip_address
+        @logger.debug("Releasing ip '#{cidr_ip}'")
+        ip_address.destroy
+      else
+        @logger.debug("Skipping releasing ip '#{cidr_ip}': not reserved")
+      end
+    end
+
+    def add(reservation)
+      cidr_ip = CIDRIP.new(reservation.ip)
+
+      reservation_type = reservation.network.ip_type(cidr_ip)
+
+      reserve_with_instance_validation(
+        reservation.instance,
+        cidr_ip,
+        reservation,
+        reservation_type.eql?(:static)
+      )
+
+      reservation.resolve_type(reservation_type)
+      reservation.mark_reserved
+      @logger.debug("Reserved ip '#{cidr_ip}' for #{reservation.network.name} as #{reservation_type}")
+    end
+
+    def allocate_dynamic_ip(reservation, subnet)
+      begin
+        ip_address = try_to_allocate_dynamic_ip(reservation, subnet)
+      rescue NoMoreIPsAvailableAndStopRetrying
+        @logger.debug('Failed to allocate dynamic ip: no more available')
+        return nil
+      rescue IpFoundInDatabaseAndCanBeRetried
+        @logger.debug('Retrying to allocate dynamic ip: probably a race condition with another deployment')
+        # IP can be taken by other deployment that runs in parallel
+        # retry until succeeds or out of range
+        retry
+      end
+
+      @logger.debug("Allocated dynamic IP '#{ip_address.ip}' for #{reservation.network.name}")
+      ip_address.to_i
+    end
+
+    private
+
+    def try_to_allocate_dynamic_ip(reservation, subnet)
+      addresses_in_use = Set.new(all_ip_addresses)
+
+      first_range_address = subnet.range.first(Objectify: true).to_i - 1
+      addresses_we_cant_allocate = addresses_in_use
+      addresses_we_cant_allocate << first_range_address
+
+      addresses_we_cant_allocate.merge(subnet.restricted_ips.to_a) unless subnet.restricted_ips.empty?
+      addresses_we_cant_allocate.merge(subnet.static_ips.to_a) unless subnet.static_ips.empty?
+      # find first in-use address whose subsequent address is not in use
+      # the subsequent address must be free
+      addr = addresses_we_cant_allocate
+               .to_a
+               .reject {|a| a < first_range_address }
+               .sort
+               .find { |a| !addresses_we_cant_allocate.include?(a+1) }
+      ip_address = NetAddr::CIDRv4.new(addr+1)
+
+      unless subnet.range == ip_address || subnet.range.contains?(ip_address)
+        raise NoMoreIPsAvailableAndStopRetrying
+      end
+
+      save_ip(ip_address, reservation, false)
+
+      ip_address
+    end
+
+    def all_ip_addresses
+      Bosh::Director::Models::IpAddress.select(:address).all.map { |a| a.address }
+    end
+
+    def reserve_with_instance_validation(instance, ip, reservation, is_static)
+      # try to save IP first before validating its instance to prevent race conditions
+      save_ip(ip, reservation, is_static)
+    rescue IpFoundInDatabaseAndCanBeRetried
+      ip_address = Bosh::Director::Models::IpAddress.first(address: ip.to_i)
+
+      retry unless ip_address
+
+      validate_instance_and_update_reservation_type(instance, ip, ip_address, reservation.network.name, is_static)
+    end
+
+    def validate_instance_and_update_reservation_type(instance, ip, ip_address, network_name, is_static)
+      reserved_instance = ip_address.instance
+      if reserved_instance == instance.model
+        if ip_address.static != is_static || ip_address.network_name != network_name
+          reservation_type = is_static ? 'static' : 'dynamic'
+          @logger.debug("Updating reservation for ip '#{ip}' with type '#{reservation_type}' and network '#{network_name}'")
+          ip_address.update(static: is_static, network_name: network_name)
+        end
+
+        return ip_address
+      else
+        raise Bosh::Director::NetworkReservationAlreadyInUse,
+          "Failed to reserve IP '#{ip}' for instance '#{instance}': " +
+            "already reserved by instance '#{reserved_instance.job}/#{reserved_instance.index}' " +
+            "from deployment '#{reserved_instance.deployment.name}'"
+      end
+    end
+
+    def save_ip(ip, reservation, is_static)
+      reservation.instance.model.add_ip_address(
+        address: ip.to_i,
+        network_name: reservation.network.name,
+        task_id: Bosh::Director::Config.current_job.task_id,
+        static: is_static
+      )
+    rescue Sequel::ValidationFailed, Sequel::DatabaseError => e
+      error_message = e.message.downcase
+      if error_message.include?('unique') || error_message.include?('duplicate')
+        raise IpFoundInDatabaseAndCanBeRetried
+      else
+        raise e
+      end
+    end
+  end
+end