bosh-director 1.3173.0 → 1.3177.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d4567ce799c76f18ac7476b9b1e15b2a2894921
-  data.tar.gz: 7f0bd2519325e7456084327985f5f6c2b9866603
+  metadata.gz: f90717cdc69804b0c839e2796bdadba05432eacb
+  data.tar.gz: c52beb6a4f72061cbc9715f40a7721df52d19f8d
 SHA512:
-  metadata.gz: a2592d11e754ce910e9ee1a454041d590f3a5d94057fadea2d765e16f6a3d9e9f8ef34a1d16cfb11fa11d67f20fbb4861b14c77b8c47a569d2af6d68c6448ce4
-  data.tar.gz: 5e601ad6cb42e5e6e2b3b6eb158e033bb8ddea9b6e6fa617be2518f1f6862b38c16024a100416a50c35166f89e801ad55968adfb2762b91e0034634f8d13f4bb
+  metadata.gz: aedd24032d99e4ac6dc32f3657d317cc9e47219f6fa9fcfd1e4668d5c5d198ea66efaa83c8d1bb5c548be2c105146b9ba83a03bd3af3f952d9914d004e72ffc8
+  data.tar.gz: 074ecb54fefc49921a885a05ade03855cac05c8061da2594cae67607781afdb3258a0d9f17abf032ca58e4f30ee2b79b4769c5b009e26efe0f64b3d05886b02f

data/db/migrations/director/20151229184742_add_vm_attributes_to_instance.rb

@@ -0,0 +1,25 @@
+Sequel.migration do
+  change do
+    alter_table(:instances) do
+      add_column :vm_cid, String, unique: true
+      add_column :agent_id, String, unique: true
+      add_column :credentials_json, String, :text => true
+      add_column :vm_env_json, String, :text => true
+      add_column :trusted_certs_sha1, String, { :default => Digest::SHA1.hexdigest('') }
+    end
+
+    self[:instances].each do |instance|
+      next unless instance[:vm_id]
+
+      vm = self[:vms].filter(id: instance[:vm_id]).first
+
+      self[:instances].filter(id: instance[:id]).update(
+        vm_cid: vm[:cid],
+        agent_id: vm[:agent_id],
+        vm_env_json: vm[:env_json],
+        trusted_certs_sha1: vm[:trusted_certs_sha1],
+        credentials_json: vm[:credentials_json]
+      )
+    end
+  end
+end

data/db/migrations/director/20160108191637_drop_vm_env_json_from_instance.rb

@@ -0,0 +1,7 @@
+Sequel.migration do
+  change do
+    alter_table(:instances) do
+      drop_column :vm_env_json
+    end
+  end
+end

data/lib/bosh/director/api/controllers/base_controller.rb

@@ -22,7 +22,7 @@ module Bosh::Director
           @stemcell_manager = StemcellManager.new
           @task_manager = TaskManager.new
           @vm_state_manager = VmStateManager.new
-          @dns_manager = DnsManager.create
+          @dns_manager = DnsManagerProvider.create
           @disk_manager = DiskManager.new(nil, @logger)
         end
 

data/lib/bosh/director/api/controllers/deployments_controller.rb

@@ -176,7 +176,7 @@ module Bosh::Director
           task = @vm_state_manager.fetch_vm_state(current_user, deployment, format)
           redirect "/tasks/#{task.id}"
         else
-          @deployment_manager.deployment_vms_to_json(deployment)
+          @deployment_manager.deployment_instances_to_json(deployment)
         end
       end
 

data/lib/bosh/director/api/deployment_manager.rb

@@ -38,22 +38,20 @@ module Bosh::Director
         Yajl::Encoder.encode(result)
       end
 
-      def deployment_vms_to_json(deployment)
-        vms = []
+      def deployment_instances_to_json(deployment)
+        instances = []
         filters = {:deployment_id => deployment.id}
-        Models::Vm.eager(:instance).filter(filters).all.each do |vm|
-          instance = vm.instance
-
-          vms << {
-            'agent_id' => vm.agent_id,
-            'cid' => vm.cid,
-            'job' => instance ? instance.job : nil,
-            'index' => instance ? instance.index : nil,
-            'id' => instance ? instance.uuid : nil
+        Models::Instance.filter(filters).exclude(vm_cid: nil).each do |instance|
+          instances << {
+            'agent_id' => instance.agent_id,
+            'cid' => instance.vm_cid,
+            'job' => instance.job,
+            'index' => instance.index,
+            'id' => instance.uuid
           }
         end
 
-        Yajl::Encoder.encode(vms)
+        Yajl::Encoder.encode(instances)
       end
     end
   end

data/lib/bosh/director/api/instance_manager.rb

@@ -31,17 +31,16 @@ module Bosh::Director
       # @param [Models::Instance] instance Instance
       # @return [AgentClient] Agent client to talk to instance
       def agent_client_for(instance)
-        vm = instance.vm
-        if vm.nil?
+        unless instance.vm_cid
           raise InstanceVmMissing,
-                "`#{instance.job}/#{instance.uuid} (#{instance.index})' doesn't reference a VM"
+                "`#{instance}' doesn't reference a VM"
         end
 
-        if vm.agent_id.nil?
-          raise VmAgentIdMissing, "VM `#{vm.cid}' doesn't have an agent id"
+        unless instance.agent_id
+          raise VmAgentIdMissing, "VM `#{instance.vm_cid}' doesn't have an agent id"
         end
 
-        AgentClient.with_vm_credentials_and_agent_id(vm.credentials, vm.agent_id)
+        AgentClient.with_vm_credentials_and_agent_id(instance.credentials, instance.agent_id)
       end
 
       def fetch_logs(username, deployment_name, job, index_or_id, options = {})

data/lib/bosh/director/api/snapshot_manager.rb

@@ -76,8 +76,7 @@ module Bosh::Director
             index: instance.index,
             director_name: Config.name,
             director_uuid: Config.uuid,
-            agent_id: instance.vm.agent_id,
-            instance_id: instance.vm_id
+            agent_id: instance.agent_id
         }
 
         instance.persistent_disks.each do |disk|

data/lib/bosh/director/cloudcheck_helper.rb

@@ -13,10 +13,10 @@ module Bosh::Director
     # still be pretty generous interval for agent to respond.
     DEFAULT_AGENT_TIMEOUT = 10
 
-    def reboot_vm(vm)
-      cloud.reboot_vm(vm.cid)
+    def reboot_vm(instance)
+      cloud.reboot_vm(instance.vm_cid)
       begin
-        agent_client(vm).wait_until_ready
+        agent_client(instance.credentials, instance.agent_id).wait_until_ready
       rescue Bosh::Director::RpcTimeout
         handler_error('Agent still unresponsive after reboot')
       rescue Bosh::Director::TaskCancelled
@@ -24,47 +24,36 @@ module Bosh::Director
       end
     end
 
-    def delete_vm(vm)
+    def delete_vm(instance)
       # Paranoia: don't blindly delete VMs with persistent disk
-      disk_list = agent_timeout_guard(vm) { |agent| agent.list_disk }
+      disk_list = agent_timeout_guard(instance.vm_cid, instance.credentials, instance.agent_id) { |agent| agent.list_disk }
       if disk_list.size != 0
         handler_error('VM has persistent disk attached')
       end
 
-      vm_deleter.delete_vm(vm)
+      vm_deleter.delete_for_instance(instance)
     end
 
-    def delete_vm_reference(vm, options={})
-      if vm.cid && !options[:skip_cid_check]
-        handler_error('VM has a CID')
-      end
-
-      vm.destroy
+    def delete_vm_reference(instance)
+      instance.update(vm_cid: nil, agent_id: nil, trusted_certs_sha1: nil, credentials: nil)
     end
 
-    def recreate_vm(vm)
-      @logger.debug("Recreating Vm: #{vm.inspect}")
-      unless vm.instance
-        handler_error('VM does not have an associated instance')
-      end
-      instance_model = vm.instance
-      vm_env = vm.env
+    def recreate_vm(instance)
+      @logger.debug("Recreating Vm: #{@instance})")
+      existing_vm_env = instance.vm_env
 
-      handler_error("VM doesn't belong to any deployment") unless vm.deployment
-      handler_error('Failed to recreate VM without instance') unless vm.instance
-
-      validate_spec(vm.instance.spec)
-      validate_env(vm.env)
+      validate_spec(instance.spec)
+      validate_env(instance.vm_env)
 
       instance_plan_to_delete = DeploymentPlan::InstancePlan.new(
-        existing_instance: instance_model,
+        existing_instance: instance,
         instance: nil,
         desired_instance: nil,
         network_plans: []
       )
 
       begin
-        vm_deleter.delete_for_instance_plan(instance_plan_to_delete)
+        vm_deleter.delete_for_instance(instance_plan_to_delete.existing_instance)
       rescue Bosh::Clouds::VMNotFound
         # One situation where this handler is actually useful is when
         # VM has already been deleted but something failed after that
@@ -72,32 +61,32 @@ module Bosh::Director
         # to ignore "VM not found" errors in `delete_vm' and let the method
         # proceed creating a new VM. Other errors are not forgiven.
 
-        @logger.warn("VM '#{vm.cid}' might have already been deleted from the cloud")
+        @logger.warn("VM '#{instance.vm_cid}' might have already been deleted from the cloud")
       end
 
-      instance_plan_to_create = create_instance_plan(instance_model, vm_env)
+      instance_plan_to_create = create_instance_plan(instance, existing_vm_env)
 
       vm_creator.create_for_instance_plan(
         instance_plan_to_create,
-        Array(instance_model.persistent_disk_cid)
+        Array(instance.persistent_disk_cid)
       )
 
-      dns_manager = DnsManager.create
+      dns_manager = DnsManagerProvider.create
       dns_names_to_ip = {}
 
       instance_plan_to_create.existing_instance.spec['networks'].each do |network_name, network|
-        index_dns_name = dns_manager.dns_record_name(instance_model.index, instance_model.job, network_name, instance_model.deployment.name)
+        index_dns_name = dns_manager.dns_record_name(instance.index, instance.job, network_name, instance.deployment.name)
         dns_names_to_ip[index_dns_name] = network['ip']
-        id_dns_name = dns_manager.dns_record_name(instance_model.uuid, instance_model.job, network_name, instance_model.deployment.name)
+        id_dns_name = dns_manager.dns_record_name(instance.uuid, instance.job, network_name, instance.deployment.name)
         dns_names_to_ip[id_dns_name] = network['ip']
       end
 
-      @logger.debug("Updating DNS record for instance: #{instance_model.inspect}; to: #{dns_names_to_ip.inspect}")
-      dns_manager.update_dns_record_for_instance(instance_model, dns_names_to_ip)
+      @logger.debug("Updating DNS record for instance: #{instance.inspect}; to: #{dns_names_to_ip.inspect}")
+      dns_manager.update_dns_record_for_instance(instance, dns_names_to_ip)
       dns_manager.flush_dns_cache
 
-      cleaner = RenderedJobTemplatesCleaner.new(instance_model, App.instance.blobstores.blobstore, @logger)
-      InstanceUpdater::StateApplier.new(instance_plan_to_create, agent_client(instance_model.vm), cleaner, @logger).apply
+      cleaner = RenderedJobTemplatesCleaner.new(instance, App.instance.blobstores.blobstore, @logger)
+      InstanceUpdater::StateApplier.new(instance_plan_to_create, agent_client(instance.credentials, instance.agent_id), cleaner, @logger).apply
     end
 
     private
@@ -140,28 +129,19 @@ module Bosh::Director
       raise Bosh::Director::ProblemHandlerError, message
     end
 
-    def instance_name(vm)
-      instance = vm.instance
-      return "Unknown VM" if instance.nil?
-
-      job = instance.job || "unknown job"
-      index = instance.index || "unknown index"
-      "#{job}/#{index}"
-    end
-
-    def agent_client(vm, timeout = DEFAULT_AGENT_TIMEOUT, retries = 0)
+    def agent_client(vm_credentials, agent_id, timeout = DEFAULT_AGENT_TIMEOUT, retries = 0)
       options = {
         :timeout => timeout,
         :retry_methods => { :get_state => retries }
       }
       @clients ||= {}
-      @clients[vm.agent_id] ||= AgentClient.with_vm_credentials_and_agent_id(vm.credentials, vm.agent_id, options)
+      @clients[agent_id] ||= AgentClient.with_vm_credentials_and_agent_id(vm_credentials, agent_id, options)
     end
 
-    def agent_timeout_guard(vm, &block)
-      yield agent_client(vm)
+    def agent_timeout_guard(vm_cid, vm_credentials, agent_id, &block)
+      yield agent_client(vm_credentials, agent_id)
     rescue Bosh::Director::RpcTimeout
-      handler_error("VM `#{vm.cid}' is not responding")
+      handler_error("VM `#{vm_cid}' is not responding")
     end
 
     def vm_deleter
@@ -183,8 +163,6 @@ module Bosh::Director
     end
 
     def validate_env(env)
-      handler_error('Unable to look up VM environment') unless env
-
       unless env.kind_of?(Hash)
         handler_error('Invalid VM environment format')
       end

data/lib/bosh/director/config.rb

@@ -13,6 +13,7 @@ module Bosh::Director
         :db,
         :dns,
         :dns_db,
+        # @todo @for-a-refactorer according to grep of "Config.dns_domain_name" I'm pretty sure this can be removed
         :dns_domain_name,
         :event_log,
         :logger,
@@ -149,7 +150,7 @@ module Bosh::Director
           end
         end
 
-        @dns_manager = DnsManager.create
+        @dns_manager = DnsManagerProvider.create
         @uuid = override_uuid || Bosh::Director::Models::DirectorAttribute.find_or_create_uuid(@logger)
         @logger.info("Director UUID: #{@uuid}")
 

data/lib/bosh/director/deployment_deleter.rb

@@ -19,10 +19,6 @@ module Bosh::Director
       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
@@ -48,22 +44,5 @@ module Bosh::Director
         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

@@ -5,7 +5,6 @@ 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'
@@ -56,6 +55,7 @@ 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/network_reservation_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'

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

@@ -6,13 +6,13 @@ module Bosh::Director
         @logger = logger
       end
 
-      def get_state(vm_model)
-        @logger.debug("Requesting current VM state for: #{vm_model.agent_id}")
-        agent = AgentClient.with_vm_credentials_and_agent_id(vm_model.credentials, vm_model.agent_id)
+      def get_state(instance)
+        @logger.debug("Requesting current VM state for: #{instance.agent_id}")
+        agent = AgentClient.with_vm_credentials_and_agent_id(instance.credentials, instance.agent_id)
         state = agent.get_state
 
         @logger.debug("Received VM state: #{state.pretty_inspect}")
-        verify_state(vm_model, state)
+        verify_state(instance, state)
         @logger.debug('Verified VM state')
 
         state.delete('release')
@@ -22,25 +22,13 @@ module Bosh::Director
         state
       end
 
-      def verify_state(vm_model, state)
-        instance = vm_model.instance
-
+      def verify_state(instance, state)
         unless state.kind_of?(Hash)
-          @logger.error("Invalid state for `#{vm_model.cid}': #{state.pretty_inspect}")
+          @logger.error("Invalid state for `#{instance.vm_cid}': #{state.pretty_inspect}")
           raise AgentInvalidStateFormat,
-            "VM `#{vm_model.cid}' returns invalid state: " +
+            "VM `#{instance.vm_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

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

@@ -18,11 +18,11 @@ module Bosh::Director
       bind_releases
 
       migrate_legacy_dns_records
-
-      instance_repo = Bosh::Director::DeploymentPlan::InstanceRepository.new(@logger)
+      network_reservation_repository = Bosh::Director::DeploymentPlan::NetworkReservationRepository.new(@deployment_plan, @logger)
+      instance_repo = Bosh::Director::DeploymentPlan::InstanceRepository.new(network_reservation_repository, @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_plan_factory = Bosh::Director::DeploymentPlan::InstancePlanFactory.new(instance_repo, states_by_existing_instance, @deployment_plan.skip_drain, index_assigner, network_reservation_repository, {'recreate' => @deployment_plan.recreate})
       instance_planner = Bosh::Director::DeploymentPlan::InstancePlanner.new(instance_plan_factory, @logger)
       desired_jobs = @deployment_plan.jobs
 
@@ -38,12 +38,9 @@ module Bosh::Director
       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) }
 
-      mark_unknown_vms_for_deletion
-
       bind_stemcells
       bind_templates
       bind_properties
-      bind_unallocated_vms
       bind_instance_networks
       bind_dns
       bind_links
@@ -67,11 +64,11 @@ module Bosh::Director
       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
+          if existing_instance.vm_cid
             pool.process do
-              with_thread_name("binding agent state for (#{existing_instance.job}/#{existing_instance.index})") do
+              with_thread_name("binding agent state for (#{existing_instance}") do
                 # getting current state to obtain IP of dynamic networks
-                state = DeploymentPlan::AgentStateMigrator.new(@deployment_plan, @logger).get_state(existing_instance.vm)
+                state = DeploymentPlan::AgentStateMigrator.new(@deployment_plan, @logger).get_state(existing_instance)
                 lock.synchronize do
                   current_states_by_existing_instance.merge!(existing_instance => state)
                 end
@@ -83,27 +80,6 @@ module Bosh::Director
       current_states_by_existing_instance
     end
 
-    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
-
-    # Looks at every job instance in the deployment plan and binds it to the
-    # instance database model (idle VM is also created in the appropriate
-    # resource pool if necessary)
-    # @return [void]
-    def bind_unallocated_vms
-      @deployment_plan.jobs_starting_on_deploy.each(&:bind_unallocated_vms)
-    end
-
     def bind_instance_networks
       # CHANGEME: something about instance plan's new network plans
       @deployment_plan.jobs_starting_on_deploy.each do |job|