bosh-director 1.3160.0 → 1.3163.0

data/lib/bosh/director/compile_task.rb

@@ -148,7 +148,7 @@ module Bosh::Director
           if BlobUtil.exists_in_global_cache?(package, cache_key)
             event_log.track("Downloading '#{package.desc}' from global cache") do
               # has side effect of putting CompiledPackage model in db
-              compiled_package = BlobUtil.fetch_from_global_cache(package, stemcell, cache_key, dependency_key)
+              compiled_package = BlobUtil.fetch_from_global_cache(package, stemcell.model, cache_key, dependency_key)
             end
           end
         end

data/lib/bosh/director/compile_task_generator.rb

@@ -13,7 +13,7 @@ module Bosh::Director
       # has no cycles: this is being enforced on release upload.
       # Other than that it's a vanilla DFS.
 
-      @logger.info("Checking whether package `#{package.desc}' needs to be compiled for stemcell `#{stemcell.desc}'")
+      @logger.info("Checking whether package `#{package.desc}' needs to be compiled for stemcell `#{stemcell.model.desc}'")
       task_key = [package.id, stemcell.id]
       task = compile_tasks[task_key]
 
@@ -26,7 +26,7 @@ module Bosh::Director
 
       transitive_dependencies = release_version.transitive_dependencies(package)
       package_dependency_key = Models::CompiledPackage.create_dependency_key(transitive_dependencies)
-      package_cache_key = Models::CompiledPackage.create_cache_key(package, transitive_dependencies, stemcell)
+      package_cache_key = Models::CompiledPackage.create_cache_key(package, transitive_dependencies, stemcell.model)
 
       task = CompileTask.new(package, stemcell, job, package_dependency_key, package_cache_key)
 

data/lib/bosh/director/config.rb

@@ -1,6 +1,5 @@
 require 'fileutils'
 require 'logging'
-require 'bosh/director/dns_helper'
 
 module Bosh::Director
 
@@ -8,8 +7,6 @@ module Bosh::Director
 
   class Config
     class << self
-      include DnsHelper
-
       attr_accessor(
         :base_dir,
         :cloud_options,
@@ -34,7 +31,8 @@ module Bosh::Director
         :enable_snapshots,
         :max_vm_create_tries,
         :nats_uri,
-        :default_ssh_options
+        :default_ssh_options,
+        :keep_unreachable_vms
       )
 
       attr_reader(
@@ -133,12 +131,25 @@ module Bosh::Director
         @db_config = config['db']
         @db = configure_db(config['db'])
         @dns = config['dns']
-        @dns_domain_name = 'bosh'
-        if @dns
-          @dns_db = configure_db(@dns['db']) if @dns['db']
-          @dns_domain_name = canonical(@dns['domain_name']) if @dns['domain_name']
+        if @dns && @dns['db']
+          @dns_db = configure_db(@dns['db'])
+          if @dns_db
+            # Load these constants early.
+            # These constants are not 'require'd, they are 'autoload'ed
+            # in models.rb. We're seeing that in 1.9.3 that sometimes
+            # the constants loaded from one thread are not visible to other threads,
+            # causing failures.
+            # These constants cannot be required because they are Sequel model classes
+            # that refer to database configuration that is only present when the (optional)
+            # powerdns job is present and configured and points to a valid DB.
+            # This is an attempt to make sure the constants are loaded
+            # before forking off to other threads, hopefully eliminating the errors.
+            Bosh::Director::Models::Dns::Record.class
+            Bosh::Director::Models::Dns::Domain.class
+          end
         end
 
+        @dns_manager = DnsManager.create
         @uuid = override_uuid || Bosh::Director::Models::DirectorAttribute.find_or_create_uuid(@logger)
         @logger.info("Director UUID: #{@uuid}")
 
@@ -150,6 +161,8 @@ module Bosh::Director
         @trusted_certs = config['trusted_certs'] || ''
         @ignore_missing_gateway = config['ignore_missing_gateway']
 
+        @keep_unreachable_vms = config.fetch('keep_unreachable_vms', false)
+
         Bosh::Clouds::Config.configure(self)
 
         @lock = Monitor.new
@@ -281,10 +294,6 @@ module Bosh::Director
         !threaded[:redis].nil?
       end
 
-      def dns_enabled?
-        !@dns_db.nil?
-      end
-
       def encryption?
         @encryption
       end

data/lib/bosh/director/deployment_deleter.rb

@@ -0,0 +1,69 @@
+module Bosh::Director
+  class DeploymentDeleter
+    def initialize(event_log, logger, dns_manager, max_threads)
+      @event_log = event_log
+      @logger = logger
+      @dns_manager = dns_manager
+      @max_threads = max_threads
+    end
+
+    def delete(deployment_model, instance_deleter, vm_deleter)
+      instance_plans = deployment_model.instances.map do |instance_model|
+        DeploymentPlan::InstancePlan.new(
+          existing_instance: instance_model,
+          instance: nil,
+          desired_instance: nil,
+          network_plans: []
+        )
+      end
+      event_log_stage = @event_log.begin_stage('Deleting instances', instance_plans.size)
+      instance_deleter.delete_instance_plans(instance_plans, event_log_stage, max_threads: @max_threads)
+
+      # For backwards compatibility for VMs that did not have instances
+      deployment_model.reload
+      delete_vms(vm_deleter, deployment_model.vms)
+
+      @event_log.begin_stage('Removing deployment artifacts', 3)
+
+      @event_log.track('Detaching stemcells') do
+        @logger.info('Detaching stemcells')
+        deployment_model.remove_all_stemcells
+      end
+
+      @event_log.track('Detaching releases') do
+        @logger.info('Detaching releases')
+        deployment_model.remove_all_release_versions
+      end
+
+      @event_log.begin_stage('Deleting properties', deployment_model.properties.count)
+      @logger.info('Deleting deployment properties')
+      deployment_model.properties.each do |property|
+        @event_log.track(property.name) do
+          property.destroy
+        end
+      end
+
+      @event_log.track('Destroying deployment') do
+        @logger.info('Destroying deployment')
+        deployment_model.destroy
+      end
+    end
+
+    private
+
+    def delete_vms(vm_deleter, vms)
+      ThreadPool.new(max_threads: @max_threads).wrap do |pool|
+        @event_log.begin_stage('Deleting idle VMs', vms.count)
+
+        vms.each do |vm|
+          pool.process do
+            @event_log.track("#{vm.cid}") do
+              @logger.info("Deleting idle vm #{vm.cid}")
+              vm_deleter.delete_vm(vm)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bosh/director/deployment_plan.rb

@@ -3,18 +3,26 @@ module Bosh::Director
   end
 end
 
+require 'bosh/director/deployment_plan/availability_zone'
 require 'bosh/director/deployment_plan/compilation_config'
 require 'bosh/director/deployment_plan/vm'
+require 'bosh/director/deployment_plan/desired_instance'
+require 'bosh/director/deployment_plan/deployment_validator'
 require 'bosh/director/deployment_plan/instance'
+require 'bosh/director/deployment_plan/instance_plan'
+require 'bosh/director/deployment_plan/instance_planner'
 require 'bosh/director/deployment_plan/job'
 require 'bosh/director/deployment_plan/network'
-require 'bosh/director/deployment_plan/network_subnet'
+require 'bosh/director/deployment_plan/manual_network_subnet'
+require 'bosh/director/deployment_plan/dynamic_network_subnet'
 require 'bosh/director/deployment_plan/compiled_package'
-require 'bosh/director/deployment_plan/resource_pools'
-require 'bosh/director/deployment_plan/instance_vm_binder'
+require 'bosh/director/deployment_plan/ip_provider/ip_provider'
+require 'bosh/director/deployment_plan/ip_provider/ip_provider_factory'
 require 'bosh/director/deployment_plan/multi_job_updater'
 require 'bosh/director/deployment_plan/release_version'
 require 'bosh/director/deployment_plan/resource_pool'
+require 'bosh/director/deployment_plan/env'
+require 'bosh/director/deployment_plan/vm_type'
 require 'bosh/director/deployment_plan/stemcell'
 require 'bosh/director/deployment_plan/template'
 require 'bosh/director/deployment_plan/update_config'
@@ -22,12 +30,35 @@ require 'bosh/director/deployment_plan/dynamic_network'
 require 'bosh/director/deployment_plan/manual_network'
 require 'bosh/director/deployment_plan/vip_network'
 require 'bosh/director/deployment_plan/planner'
-require 'bosh/director/deployment_plan/dns_binder'
+require 'bosh/director/deployment_plan/package_validator'
 require 'bosh/director/deployment_plan/notifier'
+require 'bosh/director/deployment_plan/compilation_instance_pool'
 require 'bosh/director/deployment_plan/steps/update_step'
 require 'bosh/director/deployment_plan/steps/package_compile_step'
 require 'bosh/director/deployment_plan/assembler'
+require 'bosh/director/deployment_plan/agent_state_migrator'
 require 'bosh/director/deployment_plan/planner_factory'
 require 'bosh/director/deployment_plan/manifest_migrator'
+require 'bosh/director/deployment_plan/manifest_validator'
 require 'bosh/director/deployment_plan/deployment_repo'
+require 'bosh/director/deployment_plan/global_network_resolver'
+require 'bosh/director/deployment_plan/links/link'
+require 'bosh/director/deployment_plan/links/link_path'
+require 'bosh/director/deployment_plan/links/links_resolver'
+require 'bosh/director/deployment_plan/links/link_lookup'
+require 'bosh/director/deployment_plan/links/template_link'
+require 'bosh/director/deployment_plan/instance_network_reservations'
 require 'bosh/director/deployment_plan/options/skip_drain'
+require 'bosh/director/deployment_plan/ip_provider/in_memory_ip_repo'
+require 'bosh/director/deployment_plan/ip_provider/database_ip_repo'
+require 'bosh/director/deployment_plan/network_settings'
+require 'bosh/director/deployment_plan/job_migrator'
+require 'bosh/director/deployment_plan/instance_plan_sorter'
+require 'bosh/director/deployment_plan/instance_plan_factory'
+require 'bosh/director/deployment_plan/instance_repository'
+require 'bosh/director/deployment_plan/job_network_parser'
+require 'bosh/director/deployment_plan/job_availability_zone_parser'
+require 'bosh/director/deployment_plan/placement_planner'
+require 'bosh/director/deployment_plan/network_planner'
+require 'bosh/director/deployment_plan/instance_spec.rb'
+require 'bosh/director/dns/powerdns'

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

@@ -0,0 +1,47 @@
+module Bosh::Director
+  module DeploymentPlan
+    class AgentStateMigrator
+      def initialize(deployment_plan, logger)
+        @deployment_plan = deployment_plan
+        @logger = logger
+      end
+
+      def get_state(vm_model)
+        @logger.debug("Requesting current VM state for: #{vm_model.agent_id}")
+        agent = AgentClient.with_vm(vm_model)
+        state = agent.get_state
+
+        @logger.debug("Received VM state: #{state.pretty_inspect}")
+        verify_state(vm_model, state)
+        @logger.debug('Verified VM state')
+
+        state.delete('release')
+        if state.include?('job')
+          state['job'].delete('release')
+        end
+        state
+      end
+
+      def verify_state(vm_model, state)
+        instance = vm_model.instance
+
+        unless state.kind_of?(Hash)
+          @logger.error("Invalid state for `#{vm_model.cid}': #{state.pretty_inspect}")
+          raise AgentInvalidStateFormat,
+            "VM `#{vm_model.cid}' returns invalid state: " +
+              "expected Hash, got #{state.class}"
+        end
+
+        actual_job = state['job'].is_a?(Hash) ? state['job']['name'] : nil
+        actual_index = state['index']
+
+        if instance.nil? && !actual_job.nil?
+          raise AgentUnexpectedJob,
+            "VM `#{vm_model.cid}' is out of sync: " +
+              "it reports itself as `#{actual_job}/#{actual_index}' but " +
+              'there is no instance reference in DB'
+        end
+      end
+    end
+  end
+end

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

@@ -5,262 +5,95 @@ module Bosh::Director
     include LockHelper
     include IpUtil
 
-    def initialize(deployment_plan, stemcell_manager, cloud, blobstore, logger, event_log)
+    def initialize(deployment_plan, stemcell_manager, dns_manager, cloud, logger)
       @deployment_plan = deployment_plan
       @cloud = cloud
       @logger = logger
-      @event_log = event_log
       @stemcell_manager = stemcell_manager
-      @blobstore = blobstore
+      @dns_manager = dns_manager
     end
 
-    # Binds release DB record(s) to a plan
-    # @return [void]
-    def bind_releases
-      releases = @deployment_plan.releases
-      with_release_locks(releases.map(&:name)) do
-        releases.each do |release|
-          release.bind_model
-        end
-      end
-    end
-
-    # Binds information about existing deployment to a plan
-    # @return [void]
-    def bind_existing_deployment
-      lock = Mutex.new
-      ThreadPool.new(:max_threads => Config.max_threads).wrap do |pool|
-        @deployment_plan.vms.each do |vm_model|
-          pool.process do
-            with_thread_name("bind_existing_deployment(#{vm_model.agent_id})") do
-              bind_existing_vm(vm_model, lock)
-            end
-          end
-        end
-      end
-    end
-
-    # Queries agent for VM state and updates deployment plan accordingly
-    # @param [Models::Vm] vm_model VM database model
-    # @param [Mutex] lock Lock to hold on to while updating deployment plan
-    def bind_existing_vm(vm_model, lock)
-      state = get_state(vm_model)
-      lock.synchronize do
-        @logger.debug('Processing VM network reservations')
-        reservations = get_network_reservations(state)
-
-        instance = vm_model.instance
-        if instance
-          bind_instance(instance, state, reservations)
-        else
-          resource_pool_name = state['resource_pool']['name']
-          resource_pool = @deployment_plan.resource_pool(resource_pool_name)
-          if resource_pool
-            @logger.debug("Binding VM to resource pool '#{resource_pool_name}'")
-            bind_idle_vm(vm_model, resource_pool, state, reservations)
-          else
-            @logger.debug("Resource pool '#{resource_pool_name}' does not exist, marking VM for deletion")
-            @deployment_plan.delete_vm(vm_model)
-          end
-        end
-        @logger.debug('Finished processing VM network reservations')
-      end
-    end
-
-    # Binds idle VM to a resource pool with a proper network reservation
-    # @param [Models::Vm] vm_model VM DB model
-    # @param [DeploymentPlan::ResourcePool] resource_pool Resource pool
-    # @param [Hash] state VM state according to its agent
-    # @param [Hash] reservations Network reservations
-    def bind_idle_vm(vm_model, resource_pool, state, reservations)
-      if reservations.any? { |network_name, reservation| reservation.static? }
-        @logger.debug("Releasing all network reservations for VM `#{vm_model.cid}'")
-        reservations.each do |network_name, reservation|
-          @logger.debug("Releasing #{reservation.type} network reservation `#{network_name}' for VM `#{vm_model.cid}'")
-          @deployment_plan.network(network_name).release(reservation)
-        end
+    def bind_models
+      @logger.info('Binding models')
+      bind_releases
 
-        @logger.debug("Deleting VM `#{vm_model.cid}' with static network reservation")
-        @deployment_plan.delete_vm(vm_model)
-        return
-      end
+      migrate_legacy_dns_records
+      bind_job_renames
 
-      @logger.debug("Adding VM `#{vm_model.cid}' to resource pool `#{resource_pool.name}'")
-      idle_vm = resource_pool.add_idle_vm
-      idle_vm.model = vm_model
-      idle_vm.current_state = state
+      instance_repo = Bosh::Director::DeploymentPlan::InstanceRepository.new(@logger)
+      states_by_existing_instance = current_states_by_instance(@deployment_plan.candidate_existing_instances)
+      index_assigner = Bosh::Director::DeploymentPlan::PlacementPlanner::IndexAssigner.new(@deployment_plan.model)
+      instance_plan_factory = Bosh::Director::DeploymentPlan::InstancePlanFactory.new(instance_repo, states_by_existing_instance, @deployment_plan.skip_drain, index_assigner, {'recreate' => @deployment_plan.recreate})
+      instance_planner = Bosh::Director::DeploymentPlan::InstancePlanner.new(instance_plan_factory, @logger)
+      desired_jobs = @deployment_plan.jobs
 
-      network_name = resource_pool.network.name
-      reservation = reservations[network_name]
-      if reservation
-        @logger.debug("Using existing `#{reservation.type}' " +
-          "network reservation of `#{reservation.ip}' for VM `#{vm_model.cid}'")
-        idle_vm.use_reservation(reservation)
-      else
-        @logger.debug("No network reservation for VM `#{vm_model.cid}'")
-      end
-    end
-
-    # @param [Models::Instance] instance_model Instance model
-    # @param [Hash] state Instance state according to agent
-    # @param [Hash] reservations Instance network reservations
-    def bind_instance(instance_model, state, reservations)
-      @logger.debug('Binding instance VM')
-
-      # Update instance, if we are renaming a job.
-      if @deployment_plan.rename_in_progress?
-        old_name = @deployment_plan.job_rename['old_name']
-        new_name = @deployment_plan.job_rename['new_name']
+      job_migrator = Bosh::Director::DeploymentPlan::JobMigrator.new(@deployment_plan, @logger)
 
-        if instance_model.job == old_name
-          @logger.info("Renaming `#{old_name}' to `#{new_name}'")
-          instance_model.update(:job => new_name)
-        end
+      desired_jobs.each do |desired_job|
+        desired_instances = desired_job.desired_instances
+        existing_instances = job_migrator.find_existing_instances(desired_job)
+        instance_plans = instance_planner.plan_job_instances(desired_job, desired_instances, existing_instances)
+        desired_job.add_instance_plans(instance_plans)
       end
 
-      instance_name = "#{instance_model.job}/#{instance_model.index}"
+      instance_plans_for_obsolete_jobs = instance_planner.plan_obsolete_jobs(desired_jobs, @deployment_plan.existing_instances)
+      instance_plans_for_obsolete_jobs.map(&:existing_instance).each { |existing_instance| @deployment_plan.mark_instance_for_deletion(existing_instance) }
 
-      job = @deployment_plan.job(instance_model.job)
-      unless job
-        @logger.debug("Job `#{instance_model.job}' not found, marking for deletion")
-        @deployment_plan.delete_instance(instance_model)
-        return
-      end
-
-      instance = job.instance(instance_model.index)
-      unless instance
-        @logger.debug("Job instance `#{instance_name}' not found, marking for deletion")
-        @deployment_plan.delete_instance(instance_model)
-        return
-      end
+      mark_unknown_vms_for_deletion
 
-      @logger.debug("Found existing job instance `#{instance_name}'")
-      instance.bind_existing_instance(instance_model, state, reservations)
-    end
-
-    def get_network_reservations(state)
-      reservations = {}
-      state['networks'].each do |name, network_config|
-        network = @deployment_plan.network(name)
-        if network
-          reservation = NetworkReservation.new(:ip => network_config['ip'])
-          network.reserve(reservation)
-          reservations[name] = reservation if reservation.reserved?
-        end
-      end
-      reservations
-    end
-
-    def get_state(vm_model)
-      @logger.debug("Requesting current VM state for: #{vm_model.agent_id}")
-      agent = AgentClient.with_defaults(vm_model.agent_id)
-      state = agent.get_state
-
-      @logger.debug("Received VM state: #{state.pretty_inspect}")
-      verify_state(vm_model, state)
-      @logger.debug('Verified VM state')
-
-      migrate_legacy_state(vm_model, state)
-      state.delete('release')
-      if state.include?('job')
-        state['job'].delete('release')
-      end
-      state
+      bind_stemcells
+      bind_templates
+      bind_properties
+      bind_unallocated_vms
+      bind_instance_networks
+      bind_dns
+      bind_links
     end
 
-    def verify_state(vm_model, state)
-      instance = vm_model.instance
+    private
 
-      if instance && instance.deployment_id != vm_model.deployment_id
-        # Both VM and instance should reference same deployment
-        raise VmInstanceOutOfSync,
-              "VM `#{vm_model.cid}' and instance " +
-              "`#{instance.job}/#{instance.index}' " +
-              "don't belong to the same deployment"
-      end
-
-      unless state.kind_of?(Hash)
-        @logger.error("Invalid state for `#{vm_model.cid}': #{state.pretty_inspect}")
-        raise AgentInvalidStateFormat,
-              "VM `#{vm_model.cid}' returns invalid state: " +
-              "expected Hash, got #{state.class}"
-      end
-
-      actual_deployment_name = state['deployment']
-      expected_deployment_name = @deployment_plan.name
-
-      if actual_deployment_name != expected_deployment_name
-        raise AgentWrongDeployment,
-              "VM `#{vm_model.cid}' is out of sync: " +
-                'expected to be a part of deployment ' +
-              "`#{expected_deployment_name}' " +
-                'but is actually a part of deployment ' +
-              "`#{actual_deployment_name}'"
-      end
-
-      actual_job = state['job'].is_a?(Hash) ? state['job']['name'] : nil
-      actual_index = state['index']
-
-      if instance.nil? && !actual_job.nil?
-        raise AgentUnexpectedJob,
-              "VM `#{vm_model.cid}' is out of sync: " +
-              "it reports itself as `#{actual_job}/#{actual_index}' but " +
-                'there is no instance reference in DB'
-      end
-
-      if instance &&
-        (instance.job != actual_job || instance.index != actual_index)
-        # Check if we are resuming a previously unfinished rename
-        if actual_job == @deployment_plan.job_rename['old_name'] &&
-           instance.job == @deployment_plan.job_rename['new_name'] &&
-           instance.index == actual_index
-
-          # Rename already happened in the DB but then something happened
-          # and agent has never been updated.
-          unless @deployment_plan.job_rename['force']
-            raise AgentRenameInProgress,
-                  "Found a job `#{actual_job}' that seems to be " +
-                  "in the middle of a rename to `#{instance.job}'. " +
-                  "Run 'rename' again with '--force' to proceed."
-          end
-        else
-          raise AgentJobMismatch,
-                "VM `#{vm_model.cid}' is out of sync: " +
-                "it reports itself as `#{actual_job}/#{actual_index}' but " +
-                "according to DB it is `#{instance.job}/#{instance.index}'"
+    # Binds release DB record(s) to a plan
+    # @return [void]
+    def bind_releases
+      releases = @deployment_plan.releases
+      with_release_locks(releases.map(&:name)) do
+        releases.each do |release|
+          release.bind_model
         end
       end
     end
 
-    def migrate_legacy_state(vm_model, state)
-      # Persisting apply spec for VMs that were introduced before we started
-      # persisting it on apply itself (this is for cloudcheck purposes only)
-      if vm_model.apply_spec.nil?
-        # The assumption is that apply_spec <=> VM state
-        vm_model.update(:apply_spec => state)
-      end
-
-      instance = vm_model.instance
-      if instance
-        disk_size = state['persistent_disk'].to_i
-        persistent_disk = instance.persistent_disk
-
-        # This is to support legacy deployments where we did not have
-        # the disk_size specified.
-        if disk_size != 0 && persistent_disk && persistent_disk.size == 0
-          persistent_disk.update(:size => disk_size)
+    def current_states_by_instance(existing_instances)
+      lock = Mutex.new
+      current_states_by_existing_instance = {}
+      ThreadPool.new(:max_threads => Config.max_threads).wrap do |pool|
+        existing_instances.each do |existing_instance|
+          if existing_instance.vm
+            pool.process do
+              with_thread_name("binding agent state for (#{existing_instance.job}/#{existing_instance.index})") do
+                # getting current state to obtain IP of dynamic networks
+                state = DeploymentPlan::AgentStateMigrator.new(@deployment_plan, @logger).get_state(existing_instance.vm)
+                lock.synchronize do
+                  current_states_by_existing_instance.merge!(existing_instance => state)
+                end
+              end
+            end
+          end
         end
       end
+      current_states_by_existing_instance
     end
 
-    # Takes a look at the current state of all resource pools in the deployment
-    # and schedules adding any new VMs if needed. VMs are NOT created at this
-    # stage, only data structures are being allocated. {ResourcePoolUpdater}
-    # will later perform actual changes based on this data.
-    # @return [void]
-    def bind_resource_pools
-      @deployment_plan.resource_pools.each do |resource_pool|
-        resource_pool.process_idle_vms
+    def mark_unknown_vms_for_deletion
+      @deployment_plan.vm_models.select { |vm| vm.instance.nil? }.each do |vm_model|
+        # VM without an instance should not exist any more. But we still
+        # delete those VMs for backwards compatibility in case if it was ever
+        # created incorrectly.
+        # It also means that it was created before global networking
+        # and should not have any network reservations in DB,
+        # so we don't worry about releasing its IPs.
+        @logger.debug('Marking VM for deletion')
+        @deployment_plan.mark_vm_for_deletion(vm_model)
       end
     end
 
@@ -273,7 +106,18 @@ module Bosh::Director
     end
 
     def bind_instance_networks
-      @deployment_plan.jobs_starting_on_deploy.each(&:bind_instance_networks)
+      # CHANGEME: something about instance plan's new network plans
+      @deployment_plan.jobs_starting_on_deploy.each do |job|
+        job.bind_instance_networks(@deployment_plan.ip_provider)
+      end
+    end
+
+    def bind_links
+      links_resolver = Bosh::Director::DeploymentPlan::LinksResolver.new(@deployment_plan, @logger)
+
+      @deployment_plan.jobs.each do |job|
+        links_resolver.resolve(job)
+      end
     end
 
     # Binds template models for each release spec in the deployment plan
@@ -296,25 +140,55 @@ module Bosh::Director
       end
     end
 
-    # Binds stemcell model for each stemcell spec in each resource pool in
+    # Binds stemcell model for each stemcell spec in
     # the deployment plan
     # @return [void]
     def bind_stemcells
-      @deployment_plan.resource_pools.each do |resource_pool|
-        stemcell = resource_pool.stemcell
+      if @deployment_plan.resource_pools && @deployment_plan.resource_pools.any?
+        @deployment_plan.resource_pools.each do |resource_pool|
+          stemcell = resource_pool.stemcell
+
+          if stemcell.nil?
+            raise DirectorError,
+              "Stemcell not bound for resource pool `#{resource_pool.name}'"
+          end
 
-        if stemcell.nil?
-          raise DirectorError,
-                "Stemcell not bound for resource pool `#{resource_pool.name}'"
+          stemcell.bind_model(@deployment_plan)
         end
+        return
+      end
 
-        stemcell.bind_model
+      @deployment_plan.stemcells.each do |_, stemcell|
+        stemcell.bind_model(@deployment_plan)
       end
     end
 
     def bind_dns
-      binder = DeploymentPlan::DnsBinder.new(@deployment_plan)
-      binder.bind_deployment
+      @dns_manager.configure_nameserver
+    end
+
+    def bind_job_renames
+      @deployment_plan.instance_models.each do |instance_model|
+        update_instance_if_rename(instance_model)
+      end
+    end
+
+    def migrate_legacy_dns_records
+      @deployment_plan.instance_models.each do |instance_model|
+        @dns_manager.migrate_legacy_records(instance_model)
+      end
+    end
+
+    def update_instance_if_rename(instance_model)
+      if @deployment_plan.rename_in_progress?
+        old_name = @deployment_plan.job_rename['old_name']
+        new_name = @deployment_plan.job_rename['new_name']
+
+        if instance_model.job == old_name
+          @logger.info("Renaming `#{old_name}' to `#{new_name}'")
+          instance_model.update(:job => new_name)
+        end
+      end
     end
   end
 end