bosh-director 1.3173.0 → 1.3177.0

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

@@ -17,7 +17,7 @@ module Bosh::Director
             configure_instance_plan(instance_plan)
             @instance_reuser.add_in_use_instance(instance_plan.instance, stemcell)
           else
-            @logger.info("Reusing compilation VM `#{instance.vm.model.cid}' for stemcell `#{stemcell.model.desc}'")
+            @logger.info("Reusing compilation VM `#{instance.model.vm_cid}' for stemcell `#{stemcell.model.desc}'")
           end
 
           yield instance
@@ -80,7 +80,7 @@ module Bosh::Director
         instance.bind_new_instance_model
 
         compilation_network = @deployment_plan.network(@deployment_plan.compilation.network_name)
-        reservation = DesiredNetworkReservation.new_dynamic(instance, compilation_network)
+        reservation = DesiredNetworkReservation.new_dynamic(instance.model, compilation_network)
         desired_instance = DeploymentPlan::DesiredInstance.new(@compile_job, nil)
         instance_plan = DeploymentPlan::InstancePlan.new(
           existing_instance: instance.model,
@@ -95,8 +95,6 @@ module Bosh::Director
       end
 
       def configure_instance_plan(instance_plan)
-        instance_plan.instance.bind_unallocated_vm
-
         @deployment_plan.ip_provider.reserve(instance_plan.network_plans.first.reservation)
         @vm_creator.create_for_instance_plan(instance_plan, [])
       end

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

@@ -8,7 +8,7 @@ module Bosh::Director
         name = safe_property(network_spec, 'name', :class => String)
         Canonicalizer.canonicalize(name)
         logger = TaggedLogger.new(logger, 'network-configuration')
-        dns_manager = DnsManager.create
+        dns_manager = DnsManagerProvider.create
 
         validate_network_has_no_key('az', name, network_spec)
         validate_network_has_no_key('azs', name, network_spec)

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

@@ -29,9 +29,6 @@ module Bosh::Director
 
       attr_reader :availability_zone
 
-      # @return [DeploymentPlan::Vm] Associated resource pool VM
-      attr_reader :vm
-
       attr_reader :existing_network_reservations
 
       def self.create_from_job(job, index, virtual_state, deployment_model, instance_state, availability_zone, logger)
@@ -80,7 +77,7 @@ module Bosh::Director
 
         # reservation generated from current state/DB
         @existing_network_reservations = InstanceNetworkReservations.new(logger)
-        @dns_manager = DnsManager.create
+        @dns_manager = DnsManagerProvider.create
 
         @virtual_state = virtual_state
       end
@@ -105,16 +102,6 @@ module Bosh::Director
         end
       end
 
-      # Looks up instance model in DB and binds it to this instance spec.
-      # Instance model is created if it's not found in DB. New VM is
-      # allocated if instance DB record doesn't reference one.
-      # @return [void]
-      # TODO: This should just be responsible to allocating the VMs and not creating instance_models
-      def bind_unallocated_vm
-        ensure_model_bound
-        ensure_vm_allocated
-      end
-
       def ensure_model_bound
         @model ||= find_or_create_model
       end
@@ -132,13 +119,6 @@ module Bosh::Director
         @uuid = @model.uuid
       end
 
-      def ensure_vm_allocated
-        @uuid = @model.uuid
-        if @model.vm.nil?
-          allocate_vm
-        end
-      end
-
       def vm_type
         @vm_type
       end
@@ -160,8 +140,6 @@ module Bosh::Director
         @uuid = existing_instance_model.uuid
         check_model_not_bound
         @model = existing_instance_model
-        allocate_vm
-        @vm.model = existing_instance_model.vm
       end
 
       def bind_existing_reservations(reservations)
@@ -196,7 +174,7 @@ module Bosh::Director
 
       def update_trusted_certs
         agent_client.update_settings(Config.trusted_certs)
-        @model.vm.update(:trusted_certs_sha1 => Digest::SHA1.hexdigest(Config.trusted_certs))
+        @model.update(:trusted_certs_sha1 => Digest::SHA1.hexdigest(Config.trusted_certs))
       end
 
       def update_cloud_properties!
@@ -204,7 +182,7 @@ module Bosh::Director
       end
 
       def agent_client
-        @agent_client ||= AgentClient.with_vm_credentials_and_agent_id(@model.vm.credentials, @model.vm.agent_id)
+        @agent_client ||= AgentClient.with_vm_credentials_and_agent_id(@model.credentials, @model.agent_id)
       end
 
       ##
@@ -279,32 +257,14 @@ module Bosh::Director
       #
       # @return [Boolean] true if the VM needs to be sent a new set of trusted certificates
       def trusted_certs_changed?
-        model_trusted_certs = @model.vm ? @model.vm.trusted_certs_sha1 : nil
         config_trusted_certs = Digest::SHA1.hexdigest(Bosh::Director::Config.trusted_certs)
-        changed = config_trusted_certs != model_trusted_certs
-        log_changes(__method__, model_trusted_certs, config_trusted_certs) if changed
+        changed = config_trusted_certs != @model.trusted_certs_sha1
+        log_changes(__method__, @model.trusted_certs_sha1, config_trusted_certs) if changed
         changed
       end
 
       def vm_created?
-        !@vm.model.nil? && @vm.model.vm_exists?
-      end
-
-      def bind_to_vm_model(vm_model)
-        @model.update(vm: vm_model)
-        @vm.model = vm_model
-        @vm.bound_instance = self
-      end
-
-      # Allocates an VM in this job resource pool and binds current instance to that VM.
-      # @return [void]
-      def allocate_vm
-        vm = Vm.new
-
-        # VM is not created yet: let's just make it reference this instance
-        # so later it knows what it needs to become
-        vm.bound_instance = self
-        @vm = vm
+        !@model.vm_cid.nil?
       end
 
       def cloud_properties

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

@@ -4,32 +4,32 @@ module Bosh::Director
       include Enumerable
       include IpUtil
 
-      def self.create_from_state(instance, state, deployment, logger)
+      def self.create_from_state(instance_model, state, deployment, logger)
         reservations = new(logger)
-        reservations.logger.debug("Creating instance network reservations from agent state for instance '#{instance}'")
+        reservations.logger.debug("Creating instance network reservations from agent state for instance '#{instance_model}'")
 
         state.fetch('networks', []).each do |network_name, network_config|
-          reservations.add_existing(instance, deployment, network_name,  network_config['ip'], '', network_config['type'])
+          reservations.add_existing(instance_model, deployment, network_name,  network_config['ip'], '', network_config['type'])
         end
 
         reservations
       end
 
-      def self.create_from_db(instance, deployment, logger)
+      def self.create_from_db(instance_model, deployment, logger)
         reservations = new(logger)
-        reservations.logger.debug("Creating instance network reservations from database for instance '#{instance}'")
+        reservations.logger.debug("Creating instance network reservations from database for instance '#{instance_model}'")
 
-        ip_addresses = instance.model.ip_addresses.clone
+        ip_addresses = instance_model.ip_addresses.clone
 
         ip_addresses.each do |ip_address|
-          reservations.add_existing(instance, deployment, ip_address.network_name, ip_address.address, ip_address.type, 'manual')
+          reservations.add_existing(instance_model, deployment, ip_address.network_name, ip_address.address, ip_address.type, 'manual')
         end
 
-        unless instance.model.spec.nil?
+        unless instance_model.spec.nil?
           # Dynamic network reservations are not saved in DB, recreating from instance spec
-          instance.model.spec.fetch('networks', []).each do |network_name, network_config|
+          instance_model.spec.fetch('networks', []).each do |network_name, network_config|
             next unless network_config['type'] == 'dynamic'
-            reservations.add_existing(instance, deployment, network_name, network_config['ip'], '', network_config['type'])
+            reservations.add_existing(instance_model, deployment, network_name, network_config['ip'], '', network_config['type'])
           end
         end
 
@@ -59,10 +59,10 @@ module Bosh::Director
         @reservations.delete(reservation)
       end
 
-      def add_existing(instance, deployment, network_name, ip, ip_type, existing_network_type)
+      def add_existing(instance_model, deployment, network_name, ip, ip_type, existing_network_type)
         network = deployment.network(network_name) || deployment.deleted_network(network_name)
-        @logger.debug("Registering existing reservation with #{ip_type} IP '#{format_ip(ip)}' for instance '#{instance}' on network '#{network.name}'")
-        reservation = ExistingNetworkReservation.new(instance, network, ip, existing_network_type)
+        @logger.debug("Registering existing reservation with #{ip_type} IP '#{format_ip(ip)}' for instance '#{instance_model}' on network '#{network.name}'")
+        reservation = ExistingNetworkReservation.new(instance_model, network, ip, existing_network_type)
         deployment.ip_provider.reserve_existing_ips(reservation)
         @reservations << reservation
       end

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

@@ -10,7 +10,7 @@ module Bosh
           @skip_drain = attrs.fetch(:skip_drain, false)
           @recreate_deployment = attrs.fetch(:recreate_deployment, false)
           @logger = attrs.fetch(:logger, Config.logger)
-          @dns_manager = DnsManager.create
+          @dns_manager = DnsManagerProvider.create
         end
 
         attr_reader :desired_instance, :existing_instance, :instance, :skip_drain, :recreate_deployment
@@ -260,8 +260,8 @@ module Bosh
         def env_changed?
           job = @desired_instance.job
 
-          if @existing_instance && @existing_instance.env && job.env.spec != @existing_instance.env
-            log_changes(__method__, @existing_instance.vm.env, job.env.spec, @existing_instance)
+          if @existing_instance && @existing_instance.vm_env && job.env.spec != @existing_instance.vm_env
+            log_changes(__method__, @existing_instance.vm_env, job.env.spec, @existing_instance)
             return true
           end
           false

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

@@ -2,15 +2,18 @@ module Bosh
   module Director
     module DeploymentPlan
       class InstancePlanFactory
-        def initialize(instance_repo, states_by_existing_instance, skip_drain_decider, index_assigner, options = {})
+        def initialize(instance_repo, states_by_existing_instance, skip_drain_decider, index_assigner, network_reservation_repository, options = {})
           @instance_repo = instance_repo
           @skip_drain_decider = skip_drain_decider
           @recreate_deployment = options.fetch('recreate', false)
           @states_by_existing_instance = states_by_existing_instance
           @index_assigner = index_assigner
+          @network_reservation_repository = network_reservation_repository
         end
 
         def obsolete_instance_plan(existing_instance_model)
+          existing_instance_state = instance_state(existing_instance_model)
+          @network_reservation_repository.fetch_network_reservations(existing_instance_model, existing_instance_state)
           InstancePlan.new(
             desired_instance: nil,
             existing_instance: existing_instance_model,
@@ -21,11 +24,10 @@ module Bosh
         end
 
         def desired_existing_instance_plan(existing_instance_model, desired_instance)
-          existing_instance_state = @states_by_existing_instance[existing_instance_model]
-
+          existing_instance_state = instance_state(existing_instance_model)
           desired_instance.index = @index_assigner.assign_index(desired_instance.job.name, existing_instance_model)
 
-          instance = @instance_repo.fetch_existing(desired_instance, existing_instance_model, existing_instance_state)
+          instance = @instance_repo.fetch_existing(existing_instance_model, existing_instance_state, desired_instance.job, desired_instance.index, desired_instance.deployment)
           instance.update_description
           InstancePlan.new(
             desired_instance: desired_instance,
@@ -48,6 +50,12 @@ module Bosh
             recreate_deployment: @recreate_deployment
           )
         end
+
+        private
+
+        def instance_state(existing_instance_model)
+          @states_by_existing_instance[existing_instance_model]
+        end
       end
     end
   end

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

@@ -28,11 +28,12 @@ module Bosh
         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|
+          obsolete_existing_instances = 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)
+              migrating_job_names.include?(existing_instance_model.job)
+          end
+          obsolete_existing_instances.map do |obsolete_existing_instance|
+            @instance_plan_factory.obsolete_instance_plan(obsolete_existing_instance)
           end
         end
 

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

@@ -1,27 +1,20 @@
 module Bosh::Director::DeploymentPlan
   class InstanceRepository
-    def initialize(logger)
+    def initialize(network_reservation_repostory, logger)
+      @network_reservation_repository = network_reservation_repostory
       @logger = logger
     end
 
-    def fetch_existing(desired_instance, existing_instance_model, existing_instance_state)
+    def fetch_existing(existing_instance_model, existing_instance_state, job, index, deployment)
       @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}")
+      job_state = job.state_for_instance(existing_instance_model) || existing_instance_model.state
+      @logger.debug("Job instance states: #{job.instance_states}, found: #{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 = Instance.create_from_job(job, index, job_state, 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
+      existing_network_reservations = @network_reservation_repository.fetch_network_reservations(existing_instance_model, existing_instance_state)
       instance.bind_existing_reservations(existing_network_reservations)
       instance
     end

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

@@ -14,7 +14,7 @@ module Bosh::Director
         deployment_name = instance.deployment_model.name
         job = instance_plan.desired_instance.job
         instance_plan = instance_plan
-        dns_manager = DnsManager.create
+        dns_manager = DnsManagerProvider.create
 
         spec = {
           'deployment' => deployment_name,
@@ -95,7 +95,7 @@ module Bosh::Director
     class TemplateSpec
       def initialize(full_spec)
         @full_spec = full_spec
-        @dns_manager = DnsManager.create
+        @dns_manager = DnsManagerProvider.create
       end
 
       def spec

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

@@ -27,7 +27,7 @@ module Bosh::Director::DeploymentPlan
       reservation_type = reservation.network.ip_type(cidr_ip)
 
       reserve_with_instance_validation(
-        reservation.instance,
+        reservation.instance_model,
         cidr_ip,
         reservation,
         reservation_type.eql?(:static)
@@ -88,7 +88,7 @@ module Bosh::Director::DeploymentPlan
       Bosh::Director::Models::IpAddress.select(:address).all.map { |a| a.address }
     end
 
-    def reserve_with_instance_validation(instance, ip, reservation, is_static)
+    def reserve_with_instance_validation(instance_model, 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
@@ -96,12 +96,12 @@ module Bosh::Director::DeploymentPlan
 
       retry unless ip_address
 
-      validate_instance_and_update_reservation_type(instance, ip, ip_address, reservation.network.name, is_static)
+      validate_instance_and_update_reservation_type(instance_model, ip, ip_address, reservation.network.name, is_static)
     end
 
-    def validate_instance_and_update_reservation_type(instance, ip, ip_address, network_name, is_static)
+    def validate_instance_and_update_reservation_type(instance_model, ip, ip_address, network_name, is_static)
       reserved_instance = ip_address.instance
-      if reserved_instance == instance.model
+      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}'")
@@ -111,14 +111,14 @@ module Bosh::Director::DeploymentPlan
         return ip_address
       else
         raise Bosh::Director::NetworkReservationAlreadyInUse,
-          "Failed to reserve IP '#{ip}' for instance '#{instance}': " +
+          "Failed to reserve IP '#{ip}' for instance '#{instance_model}': " +
             "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(
+      reservation.instance_model.add_ip_address(
         address: ip.to_i,
         network_name: reservation.network.name,
         task_id: Bosh::Director::Config.current_job.task_id,

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

@@ -48,12 +48,14 @@ module Bosh::Director::DeploymentPlan
       end
     end
 
+    def contains_ip?(ip, network_name)
+      @ips.include?({ip: ip.to_i, network_name: network_name})
+    end
+
     private
 
     def add_ip(ip, network_name)
-      entry_to_add = {ip: ip.to_i, network_name: network_name}
-
-      if @ips.include?(entry_to_add)
+      if contains_ip?(ip, network_name)
         message = "Failed to reserve IP '#{ip.ip}' for '#{network_name}': already reserved"
         @logger.error(message)
         raise Bosh::Director::NetworkReservationAlreadyInUse, message
@@ -61,6 +63,7 @@ module Bosh::Director::DeploymentPlan
 
       @logger.debug("Reserving ip '#{ip.ip}' for #{network_name}")
 
+      entry_to_add = {ip: ip.to_i, network_name: network_name}
       @ips << entry_to_add
       @recently_released_ips.delete(entry_to_add)
     end

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

@@ -51,7 +51,7 @@ module Bosh::Director
           end
 
           raise NetworkReservationNotEnoughCapacity,
-            "Failed to reserve IP for '#{reservation.instance}' for manual network '#{reservation.network.name}': no more available"
+            "Failed to reserve IP for '#{reservation.instance_model}' for manual network '#{reservation.network.name}': no more available"
 
         else
 
@@ -130,12 +130,12 @@ module Bosh::Director
       end
 
       def filter_subnet_by_instance_az(reservation)
-        instance_az = reservation.instance.availability_zone
-        if instance_az.nil?
+        instance_az_name = reservation.instance_model.availability_zone
+        if instance_az_name.nil?
           reservation.network.subnets
         else
           reservation.network.subnets.select do |subnet|
-            subnet.availability_zone_names.include?(instance_az.name)
+            subnet.availability_zone_names.include?(instance_az_name)
           end
         end
       end

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

@@ -256,15 +256,8 @@ module Bosh::Director
         end
       end
 
-      def bind_unallocated_vms
-        instances.each do |instance|
-          instance.ensure_vm_allocated
-        end
-      end
-
       def bind_instances(ip_provider)
         instances.each(&:ensure_model_bound)
-        bind_unallocated_vms
         bind_instance_networks(ip_provider)
       end