bosh-director 1.3160.0 → 1.3163.0

data/lib/bosh/director/problem_handlers/out_of_sync_vm.rb

@@ -1,64 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-module Bosh::Director
-  module ProblemHandlers
-    class OutOfSyncVm < Base
-
-      register_as :out_of_sync_vm
-      auto_resolution :ignore
-
-      def initialize(vm_id, data)
-        super
-        @vm = Models::Vm[vm_id]
-        @data = data
-
-        if @vm.nil?
-          handler_error("VM `#{vm_id}' is no longer in the database")
-        end
-
-        @deployment = @vm.deployment
-        @instance = @vm.instance
-
-        if @deployment.nil?
-          handler_error("VM `#{@vm.cid}' doesn't belong to any deployment")
-        end
-
-      end
-
-      def description
-        actual_deployment = @data["deployment"] || "unknown deployment"
-        actual_job = @data["job"] || "unknown job"
-        actual_index = @data["index"] || "unknown index"
-
-        expected = "#{@deployment.name}: #{instance_name(@vm)}"
-        actual = "#{actual_deployment}: #{actual_job}/#{actual_index}"
-
-        "VM `#{@vm.cid}' is out of sync: expected `#{expected}', got `#{actual}'"
-      end
-
-      resolution :ignore do
-        plan { "Skip for now" }
-        action { }
-      end
-
-      resolution :delete_vm do
-        plan { "Delete VM (unless it has persistent disk)"}
-        action { validate; delete_vm(@vm) }
-      end
-
-      def validate
-        state = agent_timeout_guard(@vm) { |agent | agent.get_state }
-        return if state["deployment"] != @deployment.name
-
-        # VM is no longer out of sync if no instance is referencing it,
-        # as this situation can actually be handled by regular deployment
-        if @instance.nil? ||
-            state["job"] && state["job"]["name"] == @instance.job &&
-            state["index"] == @instance.index
-          handler_error("VM is now back in sync")
-        end
-      end
-
-    end
-  end
-end

data/lib/bosh/director/problem_handlers/unbound_instance_vm.rb

@@ -1,85 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-module Bosh::Director
-  module ProblemHandlers
-    class UnboundInstanceVm < Base
-
-      register_as :unbound_instance_vm
-      auto_resolution :reassociate_vm
-
-      def initialize(vm_id, data)
-        super
-
-        @vm = Models::Vm[vm_id]
-        @data = data
-
-        if @vm.nil?
-          handler_error("VM `#{vm_id}' is no longer in the database")
-        end
-
-        if @vm.agent_id.nil?
-          handler_error("VM `#{vm_id}' doesn't have an agent id")
-        end
-
-        if @vm.cid.nil?
-          handler_error("VM `#{vm_id}' doesn't have a cloud id")
-        end
-
-      end
-
-      def description
-        job = @data["job"] || "unknown job"
-        index = @data["index"] || "unknown index"
-        "VM `#{@vm.cid}' reports itself as `#{job}/#{index}' but does not have a bound instance"
-      end
-
-      resolution :ignore do
-        plan { "Skip for now" }
-        action { }
-      end
-
-      resolution :delete_vm do
-        plan { "Delete VM (unless it has persistent disk)" }
-        action { validate; delete_vm(@vm) }
-      end
-
-      resolution :reassociate_vm do
-        plan { "Reassociate VM with corresponding instance" }
-        action { validate; reassociate_vm }
-      end
-
-      def validate
-        unless @vm.instance.nil?
-          handler_error("Instance is now bound to VM")
-        end
-
-        state = agent_timeout_guard(@vm) { |agent| agent.get_state }
-        if state["job"].nil?
-          handler_error("VM now properly reports no job")
-        end
-      end
-
-      def reassociate_vm
-        instances = Models::Instance.
-          filter(:deployment_id => @vm.deployment_id,
-                 :job => @data["job"], :index => @data["index"]).all
-
-        if instances.size > 1
-          handler_error("More than one instance in DB matches this VM")
-        end
-
-        if instances.empty?
-          handler_error("No instances in DB match this VM")
-        end
-
-        instance = instances[0]
-
-        if instance.vm
-          handler_error("The corresponding instance is associated with another VM")
-        end
-
-        instance.update(:vm => @vm)
-      end
-    end
-  end
-end

data/lib/bosh/director/resource_pool_updater.rb

@@ -1,174 +0,0 @@
-module Bosh::Director
-  class ResourcePoolUpdater
-    def initialize(resource_pool)
-      @resource_pool = resource_pool
-      @cloud = Config.cloud
-      @logger = Config.logger
-      @event_log = Config.event_log
-    end
-
-    ##
-    # Creates VMs that are considered missing from the deployment
-    #
-    # @param [ThreadPool] thread_pool Thread pool that will be used to
-    #   parallelize the operation
-    # @yield [VirtualMachine] filter for which missing VMs to create
-    def create_missing_vms(thread_pool)
-      counter = 0
-      vms_to_process = []
-
-      @resource_pool.vms.each do |vm|
-        next if vm.model
-        if !block_given? || yield(vm)
-          counter += 1
-          vms_to_process << vm
-        end
-      end
-
-      @logger.info("Creating #{counter} missing VMs")
-      vms_to_process.each_with_index do |vm, index|
-        thread_pool.process do
-          @event_log.track("#{@resource_pool.name}/#{index}") do
-            with_thread_name("create_missing_vm(#{@resource_pool.name}, #{index}/#{counter})") do
-              @logger.info("Creating missing VM")
-              create_missing_vm(vm)
-            end
-          end
-        end
-      end
-    end
-
-    # Creates missing VMs that have bound instances
-    # (as opposed to missing resource pool VMs)
-    def create_bound_missing_vms(thread_pool)
-      create_missing_vms(thread_pool) { |vm| !vm.bound_instance.nil? }
-    end
-
-    def create_missing_vm(vm)
-      deployment = @resource_pool.deployment_plan.model
-      stemcell = @resource_pool.stemcell.model
-
-      vm_model = VmCreator.new.create(deployment, stemcell, @resource_pool.cloud_properties,
-                                vm.network_settings, nil, @resource_pool.env)
-      agent = AgentClient.with_defaults(vm_model.agent_id)
-      agent.wait_until_ready
-      agent.update_settings(Config.trusted_certs)
-      vm_model.update(:trusted_certs_sha1 => Digest::SHA1.hexdigest(Config.trusted_certs))
-
-      update_state(agent, vm_model, vm)
-
-      vm.model = vm_model
-      vm.current_state = agent.get_state
-    rescue Exception => e
-      @logger.info("Cleaning up the created VM due to an error: #{e}")
-      begin
-        @cloud.delete_vm(vm_model.cid) if vm_model && vm_model.cid
-        vm_model.destroy if vm_model && vm_model.id
-      rescue Exception
-        @logger.info("Could not cleanup VM: #{vm_model.cid}") if vm_model
-      end
-      raise e
-    end
-
-    def update_state(agent, vm_model, vm)
-      state = {
-          "deployment" => @resource_pool.deployment_plan.name,
-          "resource_pool" => @resource_pool.spec,
-          "networks" => vm.network_settings
-      }
-
-      vm_model.update(:apply_spec => state)
-      agent.apply(state)
-    end
-
-    # Deletes extra VMs in a resource pool
-    # @param thread_pool Thread pool used to parallelize delete operations
-    def delete_extra_vms(thread_pool)
-      count = @resource_pool.extra_vm_count
-      @logger.info("Deleting #{count} extra VMs")
-
-      count.times do
-        vm = @resource_pool.idle_vms.shift
-        vm_cid = vm.model.cid
-
-        thread_pool.process do
-          @event_log.track("#{@resource_pool.name}/#{vm_cid}") do
-            @logger.info("Deleting extra VM: #{vm_cid}")
-            @cloud.delete_vm(vm_cid)
-            vm.model.destroy
-          end
-        end
-      end
-    end
-
-    def delete_outdated_idle_vms(thread_pool)
-      count = outdated_idle_vm_count
-      index = 0
-      index_lock = Mutex.new
-
-      @logger.info("Deleting #{count} outdated idle VMs")
-
-      @resource_pool.idle_vms.each do |vm|
-        next unless vm.model && vm.changed?
-        vm_cid = vm.model.cid
-
-        thread_pool.process do
-          @event_log.track("#{@resource_pool.name}/#{vm_cid}") do
-            index_lock.synchronize { index += 1 }
-
-            with_thread_name("delete_outdated_vm(#{@resource_pool.name}, #{index - 1}/#{count})") do
-              @logger.info("Deleting outdated VM: #{vm_cid}")
-              @cloud.delete_vm(vm_cid)
-              vm_model = vm.model
-              vm.clean_vm
-              vm_model.destroy
-            end
-          end
-        end
-      end
-    end
-
-    # Attempts to allocate a dynamic IP address for all idle VMs
-    # (unless they already have one). This allows us to fail earlier
-    # in case any of resource pools is not big enough to accommodate
-    # those VMs.
-    def reserve_networks
-      @resource_pool.reserve_dynamic_networks
-    end
-
-    def generate_agent_id
-      SecureRandom.uuid
-    end
-
-    def extra_vm_count
-      @resource_pool.extra_vm_count
-    end
-
-    def outdated_idle_vm_count
-      counter = 0
-      @resource_pool.idle_vms.each do |vm|
-        counter += 1 if vm.model && vm.changed?
-      end
-      counter
-    end
-
-    def missing_vm_count
-      counter = 0
-      @resource_pool.vms.each do |vm|
-        next if vm.model
-        counter += 1
-      end
-      counter
-    end
-
-    def bound_missing_vm_count
-      counter = 0
-      @resource_pool.vms.each do |vm|
-        next if vm.model
-        next if vm.bound_instance.nil?
-        counter += 1
-      end
-      counter
-    end
-  end
-end

data/lib/bosh/director/vm_data.rb

@@ -1,63 +0,0 @@
-module Bosh::Director
-  # A class for storing VMs and their associated data so that they can be
-  # accessed and deleted easily.
-  class VmData
-
-    # @attr [NetworkReservation] The network reservation for this VM.
-    attr_reader :reservation
-
-    # @attr [Models::Vm] The VM.
-    attr_reader :vm
-
-    # @attr[Models::Stemcell] The Stemcell this VM is running.
-    attr_reader :stemcell
-
-    # @attr [Hash] A hash containing the network reservation.
-    attr_reader :network_settings
-
-    # @attr [Integer] The agent ID running on this VM.
-    attr_reader :agent_id
-
-    # @attr [AgentClient] The agent running on this VM.
-    attr_accessor :agent
-
-    # Initializes a VmData.
-    # @param [NetworkReservation] reservation The network reservation for this VM.
-    # @param [Models::Vm] vm The VM to be reused.
-    # @param [Models::Stemcell] stemcell The Stemcell to make the VM on.
-    # @param [Hash] network_settings A hash containing the network reservation.
-    def initialize(reservation, vm, stemcell, network_settings)
-      @reservation = reservation
-      @vm = vm
-      @stemcell = stemcell
-      @network_settings = network_settings
-      @agent_id = vm.agent_id
-      @being_used = false
-      @being_used_mutex = Mutex.new
-    end
-
-    # Marks that this VM is being used.
-    # @return [Boolean] Returns whether it could successfully mark this VM as in use.
-    def mark_in_use
-      @being_used_mutex.synchronize do
-        if @being_used
-          return false
-        else
-          @being_used = true
-          return true
-        end
-      end
-    end
-
-    # Releases the current VM to be reused.
-    def release
-      @being_used_mutex.synchronize do
-        @being_used = false
-      end
-    end
-
-    def in_use?
-      @being_used
-    end
-  end
-end

data/lib/bosh/director/vm_reuser.rb

@@ -1,63 +0,0 @@
-module Bosh::Director
-  # A class for maintaining VmData objects, making reusing VMs easier.
-  class VmReuser
-    def initialize
-      @stemcells_to_vms = {}
-    end
-
-    # Adds a VM's information to the pool of VMs that can be reused.
-    # @param [NetworkReservation] reservation The network reservation for this VM.
-    # @param [Models::Vm] vm The VM to be reused.
-    # @param [Models::Stemcell] stemcell The Stemcell to make the VM on.
-    # @param [Hash] network_settings A hash containing the network reservation.
-    # @return [VmData] The VmData instance for the new VM.
-    def add_vm(reservation, vm, stemcell, network_settings)
-      vm_d = VmData.new(reservation, vm, stemcell, network_settings)
-      @stemcells_to_vms[stemcell] ||= []
-      @stemcells_to_vms[stemcell] << vm_d
-      vm_d.mark_in_use
-      vm_d
-    end
-
-    # Returns the VmData instance of a VM that is not in use and can be reused.
-    # @param [Models::Stemcell] stemcell The stemcell that the VM must be running.
-    # @return [VmData?] The VmData instance for an existing unused VM, if one exists. Otherwise, nil.
-    def get_vm(stemcell)
-      unless @stemcells_to_vms[stemcell].nil?
-        @stemcells_to_vms[stemcell].each do |vm_data|
-          if vm_data.mark_in_use
-            return vm_data
-          end
-        end
-      end
-      nil
-    end
-
-    def remove_vm(vm)
-      @stemcells_to_vms.each_value do |vms|
-        vms.each do |vm_data|
-          vms.delete(vm_data) if vm_data.vm == vm
-        end
-      end
-    end
-
-    # Gets the total number of compilation VMs created with a given stemcell.
-    # @param [Models::Stemcell] stemcell The stemcell the VMs are running.
-    # @return [Integer] The number of VMs running a given stemcell.
-    def get_num_vms(stemcell)
-      @stemcells_to_vms[stemcell].nil? ? 0 : @stemcells_to_vms[stemcell].size
-    end
-
-    # An iterator for all compilation VMs on all stemcells.
-    # @yield [VmData] Yields each VM in VmReuser.
-    def each
-      @stemcells_to_vms.each do |stemcell, vms|
-        vms.each do |vm|
-          yield vm
-        end
-      end
-    end
-
-  end
-
-end