bosh-director 1.3160.0 → 1.3163.0

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

@@ -1,15 +1,15 @@
+require 'securerandom'
+
 module Bosh::Director
   module DeploymentPlan
     # Represents a single job instance.
     class Instance
-      include DnsHelper
-
-      # @return [DeploymentPlan::Job] Associated job
-      attr_reader :job
 
       # @return [Integer] Instance index
       attr_reader :index
 
+      attr_reader :uuid
+
       # @return [Models::Instance] Instance model
       attr_reader :model
 
@@ -22,350 +22,251 @@ module Bosh::Director
       # @return [Bosh::Director::Core::Templates::RenderedTemplatesArchive]
       attr_accessor :rendered_templates_archive
 
-      # @return [Hash<String, NetworkReservation>] network reservations
-      attr_accessor :network_reservations
-
       # @return [String] job state
-      attr_accessor :state
+      attr_reader :virtual_state
 
-      # @return [Hash] current state as provided by the BOSH Agent
       attr_reader :current_state
 
+      attr_reader :availability_zone
+
       # @return [DeploymentPlan::Vm] Associated resource pool VM
       attr_reader :vm
 
-      # @return [Boolean] true if this instance needs to be recreated
-      attr_accessor :recreate
-
-      # @return [Boolean] true if this instance needs to be restarted
-      attr_accessor :restart
-
-      # Creates a new instance specification based on the job and index.
-      # @param [DeploymentPlan::Job] job associated job
-      # @param [Integer] index index for this instance
-      def initialize(job, index, logger)
-        @job = job
+      attr_reader :existing_network_reservations
+
+      def self.create_from_job(job, index, virtual_state, deployment_model, instance_state, availability_zone, logger)
+        new(
+          job.name,
+          index,
+          virtual_state,
+          job.vm_type,
+          job.stemcell,
+          job.env,
+          job.compilation?,
+          deployment_model,
+          instance_state,
+          availability_zone,
+          logger
+        )
+      end
+
+      def initialize(
+        job_name,
+        index,
+        virtual_state,
+        vm_type,
+        stemcell,
+        env,
+        compilation,
+        deployment_model,
+        instance_state,
+        availability_zone,
+        logger
+      )
         @index = index
+        @availability_zone = availability_zone
         @logger = logger
+        @deployment_model = deployment_model
+        @job_name = job_name
+        @name = "#{job_name}/#{@index}"
+        @vm_type = vm_type
+        @stemcell = stemcell
+        @env = env
+        @compilation = compilation
 
         @configuration_hash = nil
         @template_hashes = nil
         @vm = nil
-        @current_state = nil
+        @current_state = instance_state || {}
 
-        @network_reservations = {}
-        @state = job.instance_state(@index)
+        # reservation generated from current state/DB
+        @existing_network_reservations = InstanceNetworkReservations.new(logger)
+        @dns_manager = DnsManager.create
 
-        # Expanding virtual states
-        case @state
-          when 'recreate'
-            @recreate = true
-            @state = 'started'
-          when 'restart'
-            @restart = true
-            @state = 'started'
-        end
+        @virtual_state = virtual_state
+      end
+
+      def bootstrap?
+        @model && @model.bootstrap
+      end
+
+      def compilation?
+        @compilation
+      end
+
+      def job_name
+        @job_name
       end
 
       def to_s
-        "#{@job.name}/#{@index}"
+        @name
       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
-        @model ||= find_or_create_model
-        if @model.vm.nil?
-          allocate_vm
-        end
+        ensure_model_bound
+        ensure_vm_allocated
       end
 
-      ##
-      # Updates this domain object to reflect an existing instance running on an existing vm
-      def bind_existing_instance(instance_model, state, reservations)
-        check_model_not_bound
-
-        @model = instance_model
-        @current_state = state
-
-        take_network_reservations(reservations)
-        add_allocated_vm(instance_model.vm, state)
+      def ensure_model_bound
+        @model ||= find_or_create_model
       end
 
-      def apply_partial_vm_state
-        @logger.info('Applying partial VM state')
-
-        state = @vm.current_state
-        state['job'] = job.spec
-        state['index'] = index
-
-        # Apply the assignment to the VM
-        agent = AgentClient.with_defaults(@vm.model.agent_id)
-        agent.apply(state)
-
-        # Our assumption here is that director database access
-        # is much less likely to fail than VM agent communication
-        # so we only update database after we see a successful agent apply.
-        # If database update fails subsequent deploy will try to
-        # assign a new VM to this instance which is ok.
-        @vm.model.db.transaction do
-          @vm.model.update(:apply_spec => state)
-          @model.update(:vm => @vm.model)
-        end
-
-        @current_state = state
+      def bind_new_instance_model
+        @model = Models::Instance.create({
+            deployment_id: @deployment_model.id,
+            job: @job_name,
+            index: index,
+            state: state,
+            compilation: @compilation,
+            uuid: SecureRandom.uuid,
+            bootstrap: false
+          })
+        @uuid = @model.uuid
       end
 
-      def apply_vm_state
-        @logger.info('Applying VM state')
-
-        state = {
-          'deployment' => @job.deployment.name,
-          'networks' => network_settings,
-          'resource_pool' => @job.resource_pool.spec,
-          'job' => @job.spec,
-          'index' => @index,
-        }
-
-        if disk_size > 0
-          state['persistent_disk'] = disk_size
+      def ensure_vm_allocated
+        @uuid = @model.uuid
+        if @model.vm.nil?
+          allocate_vm
         end
+      end
 
-        @model.vm.update(:apply_spec => state)
+      def vm_type
+        @vm_type
+      end
 
-        agent = AgentClient.with_defaults(@model.vm.agent_id)
-        agent.apply(state)
+      def stemcell
+        @stemcell
+      end
 
-        # Agent will potentially return modified version of state
-        # with resolved dynamic networks information
-        @current_state = agent.get_state
+      def env
+        @env.spec
       end
 
-      ##
-      # Syncs instance state with instance model in DB. This is needed because
-      # not all instance states are available in the deployment manifest and we
-      # we cannot really persist this data in the agent state (as VM might be
-      # stopped or detached).
-      # @return [void]
-      def sync_state_with_db
-        check_model_bound
-
-        if @state
-          # Deployment plan explicitly sets state for this instance
-          @model.update(:state => @state)
-        elsif @model.state
-          # Instance has its state persisted from the previous deployment
-          @state = @model.state
-        else
-          # Target instance state should either be persisted in DB or provided
-          # via deployment plan, otherwise something is really wrong
-          raise InstanceTargetStateUndefined,
-                "Instance `#{self}' target state cannot be determined"
-        end
+      def deployment_model
+        @deployment_model
       end
 
-      ##
-      # Adds a new network to this instance
-      # @param [String] name network name
-      # @param [NetworkReservation] reservation
-      def add_network_reservation(name, reservation)
-        old_reservation = @network_reservations[name]
-
-        if old_reservation
-          raise NetworkReservationAlreadyExists,
-                "`#{self}' already has reservation " +
-                "for network `#{name}', IP #{old_reservation.ip}"
-        end
-        @network_reservations[name] = reservation
+      # Updates this domain object to reflect an existing instance running on an existing vm
+      def bind_existing_instance_model(existing_instance_model)
+        @uuid = existing_instance_model.uuid
+        check_model_not_bound
+        @model = existing_instance_model
+        allocate_vm
+        @vm.model = existing_instance_model.vm
       end
 
-      ##
-      # @return [Hash] BOSH network settings used for Agent apply call
-      def network_settings
-        default_properties = {}
-        @job.default_network.each do |key, value|
-          (default_properties[value] ||= []) << key
-        end
+      def bind_existing_reservations(reservations)
+        @existing_network_reservations = reservations
+      end
 
-        network_settings = {}
-        @network_reservations.each do |name, reservation|
-          network = @job.deployment.network(name)
-          network_settings[name] = network.network_settings(reservation, default_properties[name])
-
-          # Temporary hack for running errands.
-          # We need to avoid RunErrand task thinking that
-          # network configuration for errand VM differs
-          # from network configuration for its Instance.
-          #
-          # Obviously this does not account for other changes
-          # in network configuration that errand job might need.
-          # (e.g. errand job desires static ip)
-          if @job.starts_on_deploy?
-            network_settings[name]['dns_record_name'] = dns_record_name(name)
-          end
+      def apply_vm_state(spec)
+        @logger.info('Applying VM state')
 
-          # Somewhat of a hack: for dynamic networks we might know IP address, Netmask & Gateway
-          # if they're featured in agent state, in that case we put them into network spec to satisfy
-          # ConfigurationHasher in both agent and director.
-          if @current_state.is_a?(Hash) &&
-              @current_state['networks'].is_a?(Hash) &&
-              @current_state['networks'][name].is_a?(Hash) &&
-              network_settings[name]['type'] == 'dynamic'
-            %w(ip netmask gateway).each do |key|
-              network_settings[name][key] = @current_state['networks'][name][key]
-            end
-          end
-        end
-        network_settings
+        @current_state = spec.full_spec
+        agent_client.apply(spec.as_apply_spec)
+        @model.update(spec: @current_state)
       end
 
-      ##
-      # @return [Integer] persistent disk size
-      def disk_size
-        check_model_bound
+      def apply_initial_vm_state(spec)
+        # Agent will return dynamic network settings, we need to update spec with it
+        # so that we can render templates with new spec later.
+        agent_spec_keys = ['networks', 'deployment', 'job', 'index', 'id']
+        agent_partial_state = spec.as_apply_spec.select { |k, _| agent_spec_keys.include?(k) }
+        agent_client.apply(agent_partial_state)
 
-        if @model.persistent_disk
-          @model.persistent_disk.size
-        else
-          0
+        instance_spec_keys = agent_spec_keys + ['stemcell', 'vm_type']
+        instance_partial_state = spec.full_spec.select { |k, _| instance_spec_keys.include?(k) }
+        @current_state.merge!(instance_partial_state)
+
+        agent_state = agent_client.get_state
+        unless agent_state.nil?
+          @current_state['networks'] = agent_state['networks']
+          @model.update(spec: @current_state)
         end
       end
 
-      ##
-      # @return [Hash] persistent disk cloud properties
-      def disk_cloud_properties
-        check_model_bound
+      def update_trusted_certs
+        agent_client.update_settings(Config.trusted_certs)
+        @model.vm.update(:trusted_certs_sha1 => Digest::SHA1.hexdigest(Config.trusted_certs))
+      end
 
-        if @model.persistent_disk
-          @model.persistent_disk.cloud_properties
-        else
-          {}
-        end
+      def update_cloud_properties!
+        @model.update(cloud_properties: JSON.dump(cloud_properties))
       end
 
-      ##
-      # @return [Hash<String, String>] dns record hash of dns name and IP
-      def dns_record_info
-        dns_record_info = {}
-        network_settings.each do |network_name, network|
-          name = dns_record_name(network_name)
-          dns_record_info[name] = network['ip']
-        end
-        dns_record_info
+      def agent_client
+        @agent_client ||= AgentClient.with_vm(@model.vm)
       end
 
       ##
       # @return [String] dns record name
-      def dns_record_name(network_name)
-        [index, job.canonical_name, canonical(network_name), job.deployment.canonical_name, dns_domain_name].join('.')
+      def dns_record_name(hostname, network_name)
+        [hostname, job.canonical_name, Canonicalizer.canonicalize(network_name), Canonicalizer.canonicalize(@deployment_model.name), @dns_manager.dns_domain_name].join('.')
       end
 
-      ##
-      # @return [Boolean] returns true if the persistent disk is attached to the VM
-      def disk_currently_attached?
-        current_state['persistent_disk'].to_i > 0
+      def cloud_properties_changed?
+        changed = cloud_properties != @model.cloud_properties_hash
+        log_changes(__method__, @model.cloud_properties_hash, cloud_properties) if changed
+        changed
       end
 
       ##
-      # @return [Boolean] returns true if the network configuration changed
-      def networks_changed?
-        network_settings != @current_state['networks']
+      # @return [Boolean] returns true if the expected configuration hash
+      #   differs from the one provided by the VM
+      def configuration_changed?
+        changed = configuration_hash != @current_state['configuration_hash']
+        log_changes(__method__, @current_state['configuration_hash'], configuration_hash) if changed
+        changed
       end
 
-      ##
-      # @return [Boolean] returns true if the expected resource pool differs from the one provided by the VM
-      def resource_pool_changed?
-        if @recreate || @job.deployment.recreate
-          return true
-        end
-
-        if @job.resource_pool.spec != @current_state['resource_pool']
-          return true
-        end
-
-        # env is not a part of a resource pool spec but rather gets persisted
-        # in director DB, hence the check below
-        # NOTE: we only update VMs that have env persisted to avoid recreating
-        # everything, so if the director gets updated from the version that
-        # doesn't persist VM env to the version that does, there needs to
-        # be at least one deployment that recreates all VMs before the following
-        # code path gets exercised.
-        if @model && @model.vm && @model.vm.env && @job.resource_pool.env != @model.vm.env
-          return true
-        end
+      def current_job_spec
+        @current_state['job']
+      end
 
-        false
+      def current_packages
+        @current_state['packages']
       end
 
-      ##
-      # @return [Boolean] returns true if the expected configuration hash
-      #   differs from the one provided by the VM
-      def configuration_changed?
-        configuration_hash != @current_state['configuration_hash']
+      def current_job_state
+        @current_state['job_state']
       end
 
-      ##
-      # @return [Boolean] returns true if the expected job configuration differs
-      #   from the one provided by the VM
-      def job_changed?
-        return true if @current_state.nil?
-
-        job_spec = @job.spec
-        if job_spec != @current_state['job']
-          # The agent job spec could be in legacy form.  job_spec cannot be,
-          # though, because we got it from the spec function in job.rb which
-          # automatically makes it non-legacy.
-          return job_spec != Job.convert_from_legacy_spec(@current_state['job'])
-        end
-        return false
+      def update_state
+        @model.update(state: state)
       end
 
-      ##
-      # @return [Boolean] returns true if the expected packaged of the running
-      #   instance differ from the ones provided by the VM
-      def packages_changed?
-        @job.package_spec != @current_state['packages']
+      def update_description
+        @model.update(job: job_name, index: index)
       end
 
-      ##
-      # @return [Boolean] returns true if the expected persistent disk or cloud_properties differs
-      #   from the state currently configured on the VM
-      def persistent_disk_changed?
-        new_disk_size = @job.persistent_disk_pool ? @job.persistent_disk_pool.disk_size : 0
-        new_disk_cloud_properties = @job.persistent_disk_pool ? @job.persistent_disk_pool.cloud_properties : {}
-        return true if new_disk_size != disk_size
+      def mark_as_bootstrap
+        @model.update(bootstrap: true)
+      end
 
-        new_disk_size != 0 && new_disk_cloud_properties != disk_cloud_properties
+      def unmark_as_bootstrap
+        @model.update(bootstrap: false)
       end
 
-      ##
-      # @return [Boolean] returns true if the DNS records configured for the
-      #   instance differ from the ones configured on the DNS server
-      def dns_changed?
-        if Config.dns_enabled?
-          dns_record_info.any? do |name, ip|
-            Models::Dns::Record.find(:name => name, :type => 'A',
-                                     :content => ip).nil?
-          end
-        else
-          false
-        end
+      def assign_availability_zone(availability_zone)
+        @availability_zone = availability_zone
+        @model.update(availability_zone: availability_zone_name)
       end
 
-      ##
-      # Checks if agent view of the instance state is consistent with target
-      # instance state.
-      #
-      # In case the instance current state is 'detached' we should never get to
-      # this method call.
-      # @return [Boolean] returns true if the expected job state differs from
-      #   the one provided by the VM
-      def state_changed?
-        @state == 'detached' ||
-          @state == 'started' && @current_state['job_state'] != 'running' ||
-          @state == 'stopped' && @current_state['job_state'] == 'running'
+      def state
+        case @virtual_state
+          when 'recreate'
+            'started'
+          when 'restart'
+            'started'
+          else
+            @virtual_state
+        end
       end
 
       ##
@@ -375,128 +276,86 @@ module Bosh::Director
       #
       # @return [Boolean] true if the VM needs to be sent a new set of trusted certificates
       def trusted_certs_changed?
-        Digest::SHA1.hexdigest(Bosh::Director::Config.trusted_certs) != @model.vm.trusted_certs_sha1
+        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
       end
 
-      ##
-      # @return [Boolean] returns true if the any of the expected specifications
-      #   differ from the ones provided by the VM
-      def changed?
-        !changes.empty?
+      def vm_created?
+        !@vm.model.nil? && @vm.model.vm_exists?
       end
 
-      ##
-      # @return [Set<Symbol>] returns a set of all of the specification differences
-      def changes
-        changes = Set.new
-        unless @state == 'detached' && @current_state.nil?
-          changes << :restart if @restart
-          changes << :resource_pool if resource_pool_changed?
-          changes << :network if networks_changed?
-          changes << :packages if packages_changed?
-          changes << :persistent_disk if persistent_disk_changed?
-          changes << :configuration if configuration_changed?
-          changes << :job if job_changed?
-          changes << :state if state_changed?
-          changes << :dns if dns_changed?
-          changes << :trusted_certs if trusted_certs_changed?
-        end
-        changes
+      def bind_to_vm_model(vm_model)
+        @model.update(vm: vm_model)
+        @vm.model = vm_model
+        @vm.bound_instance = self
       end
 
-      ##
-      # Instance spec that's passed to the VM during the BOSH Agent apply call.
-      # It's what's used for comparing the expected vs the actual state.
-      # @return [Hash<String, Object>] instance spec
-      def spec
-        spec = {
-          'deployment' => @job.deployment.name,
-          'job' => job.spec,
-          'index' => index,
-          'networks' => network_settings,
-          'resource_pool' => job.resource_pool.spec,
-          'packages' => job.package_spec,
-          'configuration_hash' => configuration_hash,
-          'properties' => job.properties,
-          'dns_domain_name' => dns_domain_name
-        }
+      # Allocates an VM in this job resource pool and binds current instance to that VM.
+      # @return [void]
+      def allocate_vm
+        vm = Vm.new
 
-        if job.persistent_disk_pool
-          # supply both for reverse compatibility with old agent
-          spec['persistent_disk'] = job.persistent_disk_pool.disk_size
-          # old agents will ignore this pool
-          spec['persistent_disk_pool'] = job.persistent_disk_pool.spec
-        else
-          spec['persistent_disk'] = 0
-        end
+        # 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
+      end
 
-        if template_hashes
-          spec['template_hashes'] = template_hashes
+      def cloud_properties
+        if @availability_zone.nil?
+          vm_type.cloud_properties
+        else
+          @availability_zone.cloud_properties.merge(vm_type.cloud_properties)
         end
+      end
 
-        # Ruby BOSH Agent does not look at 'rendered_templates_archive'
-        # since it renders job templates and then compares template hashes.
-        # Go BOSH Agent has no ability to render ERB so pre-rendered templates are provided.
-        if rendered_templates_archive
-          spec['rendered_templates_archive'] = rendered_templates_archive.spec
-        end
+      def availability_zone_name
+        return nil if @availability_zone.nil?
 
-        spec
+        @availability_zone.name
       end
 
-      def bind_to_vm_model(vm_model)
-        @model.update(vm: vm_model)
-        @vm.model = vm_model
-        @vm.bound_instance = self
+      def update_templates(templates)
+        transactor = Transactor.new
+        transactor.retryable_transaction(Bosh::Director::Config.db) do
+          @model.remove_all_templates
+          templates.map(&:model).each do |template_model|
+            @model.add_template(template_model)
+          end
+        end
       end
 
+      private
+
       # Looks up instance model in DB
       # @return [Models::Instance]
       def find_or_create_model
-        if @job.deployment.model.nil?
+        if @deployment_model.nil?
           raise DirectorError, 'Deployment model is not bound'
         end
 
         conditions = {
-          deployment_id: @job.deployment.model.id,
-          job: @job.name,
+          deployment_id: @deployment_model.id,
+          job: @job_name,
           index: @index
         }
 
         Models::Instance.find_or_create(conditions) do |model|
           model.state = 'started'
+          model.compilation = @compilation
+          model.uuid = SecureRandom.uuid
         end
       end
 
-      # Allocates an VM in this job resource pool and binds current instance to that VM.
-      # @return [void]
-      def allocate_vm
-        resource_pool = @job.resource_pool
-        vm = resource_pool.allocate_vm
-        network = resource_pool.network
-
-        if vm.model
-          # There's already a resource pool VM that can become our instance,
-          # so we can try to reuse its reservation
-          instance_reservation = @network_reservations[network.name]
-          if instance_reservation
-            instance_reservation.take(vm.network_reservation)
-          end
-        else
-          # 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
-
-          # this also means we no longer need previous VM network reservation
-          # (instance has its own)
-          vm.release_reservation
-        end
-
-        @vm = vm
+      # @param [Hash] network_settings map of network name to settings
+      # @return [Hash] map of network name to IP address
+      def network_to_ip(network_settings)
+        Hash[network_settings.map { |network_name, settings| [network_name, settings['ip']] }]
       end
 
-      private
-
       def check_model_bound
         if @model.nil?
           raise DirectorError, "Instance `#{self}' model is not bound"
@@ -507,35 +366,8 @@ module Bosh::Director
         raise DirectorError, "Instance `#{self}' model is already bound" if @model
       end
 
-      ##
-      # Take any existing valid network reservations
-      # @param [Hash<String, NetworkReservation>] reservations
-      # @return [void]
-      def take_network_reservations(reservations)
-        reservations.each do |name, provided_reservation|
-          reservation = @network_reservations[name]
-          if reservation
-            @logger.debug("Copying job instance `#{self}' network reservation #{provided_reservation}")
-            reservation.take(provided_reservation)
-          end
-        end
-      end
-
-      def add_allocated_vm(vm_model, state)
-        resource_pool = @job.resource_pool
-        vm = resource_pool.add_allocated_vm
-
-        reservation = @network_reservations[vm.resource_pool.network.name]
-
-        @logger.debug("Found VM '#{vm_model.cid}' running job instance '#{self}'" +
-          " in resource pool `#{resource_pool.name}'" +
-          " with reservation '#{reservation}'")
-        vm.model = vm_model
-        vm.bound_instance = self
-        vm.current_state = state
-        vm.use_reservation(reservation)
-
-        @vm = vm
+      def log_changes(method_sym, old_state, new_state)
+        @logger.debug("#{method_sym} changed FROM: #{old_state} TO: #{new_state}")
       end
     end
   end