bosh-director 1.3160.0 → 1.3163.0

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

@@ -1,68 +0,0 @@
-module Bosh::Director
-  module DeploymentPlan
-    class ResourcePools
-      def initialize(event_log, resource_pool_updaters)
-        @event_log = event_log
-        @resource_pool_updaters = resource_pool_updaters
-      end
-
-      def update
-        ThreadPool.new(:max_threads => Config.max_threads).wrap do |thread_pool|
-          # Delete extra VMs across resource pools
-          event_log.begin_stage('Deleting extra VMs', sum_across_pools(:extra_vm_count))
-          resource_pool_updaters.each do |updater|
-            updater.delete_extra_vms(thread_pool)
-          end
-          thread_pool.wait
-
-          # Delete outdated idle vms across resource pools, outdated allocated
-          # VMs are handled by instance updater
-          event_log.begin_stage('Deleting outdated idle VMs', sum_across_pools(:outdated_idle_vm_count))
-
-          resource_pool_updaters.each do |updater|
-            updater.delete_outdated_idle_vms(thread_pool)
-          end
-          thread_pool.wait
-
-          # Create missing VMs across resource pools phase 1:
-          # only creates VMs that have been bound to instances
-          # to avoid refilling the resource pool before instances
-          # that are no longer needed have been deleted.
-          event_log.begin_stage('Creating bound missing VMs', sum_across_pools(:bound_missing_vm_count))
-          resource_pool_updaters.each do |updater|
-            updater.create_bound_missing_vms(thread_pool)
-          end
-        end
-      end
-
-      def refill
-        # Instance updaters might have added some idle vms
-        # so they can be returned to resource pool. In that case
-        # we need to pre-allocate network settings for all of them.
-        resource_pool_updaters.each do |resource_pool_updater|
-          resource_pool_updater.reserve_networks
-        end
-
-        event_log.begin_stage('Refilling resource pools', sum_across_pools(:missing_vm_count))
-        ThreadPool.new(:max_threads => Config.max_threads).wrap do |thread_pool|
-          # Create missing VMs across resource pools phase 2:
-          # should be called after all instance updaters are finished to
-          # create additional VMs in order to balance resource pools
-          resource_pool_updaters.each do |resource_pool_updater|
-            resource_pool_updater.create_missing_vms(thread_pool)
-          end
-        end
-      end
-
-      private
-
-      attr_reader :event_log, :resource_pool_updaters
-
-      def sum_across_pools(counting_method)
-        resource_pool_updaters.inject(0) do |sum, updater|
-          sum + updater.send(counting_method.to_sym)
-        end
-      end
-    end
-  end
-end

data/lib/bosh/director/dns_helper.rb

@@ -1,223 +0,0 @@
-module Bosh::Director
-  module DnsHelper
-
-    # primary_ns contact serial refresh retry expire minimum
-    SOA = "localhost hostmaster@localhost 0 10800 604800 30"
-    TTL_5M = 300
-    TTL_4H = 3600 * 4
-
-    # @param [String] ip IP address
-    # @return [String] reverse dns domain name for an IP
-    def reverse_domain(ip)
-      reverse(ip, 2)
-    end
-
-    # @param [String] ip IP address
-    # @return [String] reverse dns name for an IP used for a PTR record
-    def reverse_host(ip)
-      reverse(ip, 3)
-    end
-
-    def canonical(string)
-      # a-z, 0-9, -, case insensitive, and must start with a letter
-      string = string.downcase.gsub(/_/, "-").gsub(/[^a-z0-9-]/, "")
-      if string =~ /^(\d|-)/
-        raise DnsInvalidCanonicalName,
-              "Invalid DNS canonical name `#{string}', must begin with a letter"
-      end
-      if string =~ /-$/
-        raise DnsInvalidCanonicalName,
-              "Invalid DNS canonical name `#{string}', can't end with a hyphen"
-      end
-      string
-    end
-
-    # build a list of dns servers to use
-    def dns_servers(network, spec, add_default_dns = true)
-      servers = nil
-      dns_property = safe_property(spec, "dns",
-                                   :class => Array, :optional => true)
-      if dns_property
-        servers = []
-        dns_property.each do |dns|
-          dns = NetAddr::CIDR.create(dns)
-          unless dns.size == 1
-            invalid_dns(network, "must be a single IP")
-          end
-
-          servers << dns.ip
-        end
-      end
-
-      return servers unless add_default_dns
-
-      add_default_dns_server(servers)
-    end
-
-    # returns the default DNS server
-    def default_dns_server
-      Config.dns["server"] if Config.dns
-    end
-
-    # add default dns server to an array of dns servers
-    def add_default_dns_server(servers)
-      return servers unless Config.dns_enabled?
-
-      default_server = default_dns_server
-      if default_server && default_server != "127.0.0.1"
-        (servers ||= []) << default_server
-        servers.uniq!
-      end
-
-      servers
-    end
-
-    # returns the DNS domain name
-    def dns_domain_name
-      Config.dns_domain_name
-    end
-
-    # returns the DNS name server record
-    def dns_ns_record
-      "ns.#{dns_domain_name}"
-    end
-
-    # create/update DNS A record
-    def update_dns_a_record(domain, name, ip_address)
-      record = Models::Dns::Record.find(:domain_id => domain.id,
-                                        :name => name)
-      if record.nil?
-        record = Models::Dns::Record.new(:domain_id => domain.id,
-                                         :name => name, :type => "A",
-                                         :ttl => TTL_5M)
-      end
-      record.content = ip_address
-      record.change_date = Time.now.to_i
-      record.save
-    end
-
-    # create/update DNS PTR records (for reverse lookups)
-    def update_dns_ptr_record(name, ip_address)
-      reverse_domain = reverse_domain(ip_address)
-      reverse_host = reverse_host(ip_address)
-
-      rdomain = Models::Dns::Domain.safe_find_or_create(:name => reverse_domain,
-                                                        :type => "NATIVE")
-      Models::Dns::Record.find_or_create(:domain_id => rdomain.id,
-                                         :name => reverse_domain,
-                                         :type =>'SOA', :content => SOA,
-                                         :ttl => TTL_4H)
-
-      Models::Dns::Record.find_or_create(:domain_id => rdomain.id,
-                                         :name => reverse_domain,
-                                         :type =>'NS', :ttl => TTL_4H,
-                                         :content => dns_ns_record)
-
-      record = Models::Dns::Record.find(:content => name, :type =>'PTR')
-
-      # delete the record if the IP address changed
-      if record && record.name != reverse_host
-        id = record.domain_id
-        record.destroy
-        record = nil
-
-        # delete the domain if the domain id changed and it's empty
-        if id != rdomain.id
-          delete_empty_domain(Models::Dns::Domain[id])
-        end
-      end
-
-      unless record
-        record = Models::Dns::Record.new(:domain_id => rdomain.id,
-                                         :name => reverse_host,
-                                         :type =>'PTR', :ttl => TTL_5M)
-      end
-      record.content = name
-      record.change_date = Time.now.to_i
-      record.save
-    end
-
-    # deletes all DNS records matching the pattern
-    # @param [String] record_pattern SQL pattern
-    # @param [Integer] domain_id domain record id
-    def delete_dns_records(record_pattern, domain_id=nil)
-      records = Models::Dns::Record.filter(:name.like(record_pattern))
-      if domain_id
-        records = records.filter(:domain_id => domain_id)
-      end
-
-      # delete A records and collect all IPs for later
-      ips = []
-      records.each do |record|
-        ips << record.content
-        @logger.info("Deleting DNS record: #{record.name}")
-        record.destroy
-      end
-
-      # delete PTR records from IP list
-      ips.each do |ip|
-        records = Models::Dns::Record.filter(:name.like(reverse_host(ip)))
-        records.each do |record|
-          @logger.info("Deleting reverse DNS record: #{record.name}")
-          record.destroy
-        end
-      end
-
-      # see if any of the reverse domains are empty and should be deleted
-      ips.each do |ip|
-        reverse = reverse_domain(ip)
-        rdomain = Models::Dns::Domain.filter(:name => reverse,
-                                             :type => "NATIVE")
-        rdomain.each do |domain|
-          delete_empty_domain(domain)
-        end
-      end
-    end
-
-    def delete_empty_domain(domain)
-      # If the count is 2, it means we only have the NS & SOA record
-      # and the domain is "empty" and can be deleted
-      if domain.records.size == 2
-        @logger.info("Deleting empty reverse domain #{domain.name}")
-
-        # Since DNS domain can be deleted by multiple threads
-        # it's possible for database to return 0 rows modified result.
-        # In this specific case that's a valid return value
-        # but Sequel usually considers that an error.
-        # ('Attempt to delete object did not result in a single row modification')
-        domain.require_modification = false
-
-        # Cascaded - all records are removed
-        domain.destroy
-      end
-    end
-
-    # @param [String] network name
-    # @param [String] reason
-    # @raise NetworkInvalidDns
-    def invalid_dns(network, reason)
-      raise NetworkInvalidDns,
-            "Invalid DNS for network `#{network}': #{reason}"
-    end
-
-    # Purge cached DNS records
-    def flush_dns_cache
-      flush_command = Config.dns['flush_command']
-      if flush_command && !flush_command.empty?
-        stdout, stderr, status = Open3.capture3(flush_command)
-        if status == 0
-          @logger.debug("Flushed #{stdout.chomp} records from DNS cache")
-        else
-          @logger.warn("Failed to flush DNS cache: #{stderr.chomp}")
-        end
-      end
-    end
-
-    private
-
-    def reverse(ip, n)
-      octets = ip.split(/\./)
-      "#{octets[0..n].reverse.join(".")}.in-addr.arpa"
-    end
-  end
-end

data/lib/bosh/director/instance_updater/network_updater.rb

@@ -1,110 +0,0 @@
-module Bosh::Director
-  class InstanceUpdater::NetworkUpdater
-    def initialize(instance, vm_model, agent_client, vm_updater, cloud, logger)
-      @instance = instance
-      @vm_model = vm_model
-      @agent_client = agent_client
-      @vm_updater = vm_updater
-      @cloud = cloud
-      @logger = logger
-    end
-
-    def update
-      unless @instance.networks_changed?
-        @logger.info('Skipping network re-configuration')
-        return [@vm_model, @agent_client]
-      end
-
-      network_settings = @instance.network_settings
-
-      strategies = [
-        ConfigureNetworksStrategy.new(@agent_client, network_settings, @logger),
-        PrepareNetworkChangeStrategy.new(@agent_client, network_settings, @logger),
-      ]
-
-      @logger.info("Planning to reconfigure network with settings: #{network_settings}")
-      selected_strategy = strategies.find { |s| s.before_configure_networks }
-
-      @cloud.configure_networks(@vm_model.cid, network_settings)
-
-      selected_strategy.after_configure_networks
-
-      [@vm_model, @agent_client]
-
-    rescue Bosh::Clouds::NotSupported => e
-      @logger.info("Failed reconfiguring existing VM: #{e.inspect}")
-
-      # If configure_networks CPI method cannot reconfigure VM networking
-      # (e.g. when the security groups change on AWS)
-      # it raises Bosh::Clouds::NotSupported to indicate new VM is needed.
-      @logger.info('Creating VM with new network configurations')
-      @instance.recreate = true
-      @vm_updater.update(nil)
-    end
-
-    private
-
-    # Newer agents support prepare_configure_networks/configure_networks messages
-    class ConfigureNetworksStrategy
-      def initialize(agent_client, network_settings, logger)
-        @agent_client = agent_client
-        @network_settings = network_settings
-        @logger = logger
-      end
-
-      def before_configure_networks
-        @agent_client.prepare_configure_networks(@network_settings)
-        true
-      rescue RpcRemoteException => e
-        @logger.info("Agent returned error from prepare_configure_networks: #{e.inspect}")
-        raise unless e.message =~ /unknown message/
-        false
-      end
-
-      def after_configure_networks
-        # Some CPIs might power off and then power on vm to reconfigure network adapters,
-        # so Director needs to wait for agent to become responsive
-        @logger.info('Waiting for agent to become responsive')
-        @agent_client.wait_until_ready
-
-        # Agent's configure_networks is a long running task
-        # hence we do not need to wait_until_ready after it
-        @agent_client.configure_networks(@network_settings)
-      end
-    end
-
-    # Older agents only support prepare_network_change
-    class PrepareNetworkChangeStrategy
-      def initialize(agent_client, network_settings, logger)
-        @agent_client = agent_client
-        @network_settings = network_settings
-        @logger = logger
-      end
-
-      def before_configure_networks
-        true
-      end
-
-      def after_configure_networks
-        # Some CPIs might power off and then power on vm to reconfigure network adapters,
-        # so Director needs to wait for agent to become responsive
-        @logger.info('Waiting for agent to become responsive')
-        @agent_client.wait_until_ready
-
-        # Once CPI has configured the vm and stored the new network settings at the registry,
-        # we restart the agent via a 'prepare_network_change' message in order for the agent
-        # to pick up the new network settings.
-        @agent_client.prepare_network_change(@network_settings)
-
-        # Since current implementation of prepare_network_change is to kill the agent
-        # we need to wait until the agent is ready. However, we want to avoid
-        # talking to the old agent, so we need to wait for it to die.
-        @logger.info('Sleeping after prepare_network_change message')
-        sleep(5)
-
-        @logger.info('Waiting for agent to become responsive')
-        @agent_client.wait_until_ready
-      end
-    end
-  end
-end

data/lib/bosh/director/instance_updater/vm_updater.rb

@@ -1,189 +0,0 @@
-module Bosh::Director
-  class InstanceUpdater::VmUpdater
-    def initialize(instance, vm_model, agent_client, job_renderer, cloud, max_update_tries, logger)
-      @instance = instance
-      @vm_model = vm_model
-      @agent_client = agent_client
-      @job_renderer = job_renderer
-      @cloud = cloud
-      @max_update_tries = max_update_tries
-      @logger = logger
-    end
-
-    def update(new_disk_cid)
-      if !@instance.resource_pool_changed? && !new_disk_cid
-        @logger.info('Skipping VM update')
-        return [@vm_model, @agent_client]
-      end
-
-      disk_detacher = DiskDetacher.new(@instance, @vm_model, @agent_client, @cloud, @logger)
-      disk_detacher.detach
-
-      @max_update_tries.times do |try|
-        vm_deleter = VmDeleter.new(@instance, @vm_model, @cloud, @logger)
-        vm_deleter.delete
-
-        vm_creator = VmCreator.new(@instance, @cloud, @logger)
-        @vm_model, @agent_client = vm_creator.create(new_disk_cid)
-
-        begin
-          disk_attacher = DiskAttacher.new(@instance, @vm_model, @agent_client, @cloud, @logger)
-          disk_attacher.attach
-          break
-        rescue Bosh::Clouds::NoDiskSpace => e
-          if e.ok_to_retry && try < @max_update_tries-1
-            @logger.warn("Retrying attach disk operation #{try}: #{e.inspect}")
-          else
-            @logger.warn("Failed to attach disk to new VM: #{e.inspect}")
-            raise CloudNotEnoughDiskSpace,
-                  "Not enough disk space to update `#{@instance}'"
-          end
-        end
-      end
-
-      @instance.apply_vm_state
-      @job_renderer.render_job_instance(@instance)
-
-      [@vm_model, @agent_client]
-    end
-
-    def detach
-      @logger.info('Detaching VM')
-
-      disk_detacher = DiskDetacher.new(@instance, @vm_model, @agent_client, @cloud, @logger)
-      disk_detacher.detach
-
-      vm_deleter = VmDeleter.new(@instance, @vm_model, @cloud, @logger)
-      vm_deleter.delete
-    end
-
-    def attach_missing_disk
-      if !@instance.model.persistent_disk_cid || @instance.disk_currently_attached?
-        @logger.info('Skipping attaching missing VM')
-        return
-      end
-
-      begin
-        disk_attacher = DiskAttacher.new(@instance, @vm_model, @agent_client, @cloud, @logger)
-        disk_attacher.attach
-      rescue Bosh::Clouds::NoDiskSpace => e
-        @logger.warn("Failed attaching missing disk first time: #{e.inspect}")
-        update(@instance.model.persistent_disk_cid)
-      end
-    end
-
-    private
-
-    class VmCreator
-      def initialize(instance, cloud, logger)
-        @instance = instance
-        @cloud = cloud
-        @logger = logger
-      end
-
-      def create(new_disk_id)
-        @logger.info('Creating VM')
-        vm_model = new_vm_model(new_disk_id)
-
-        begin
-          @instance.bind_to_vm_model(vm_model)
-
-          agent_client = AgentClient.with_defaults(vm_model.agent_id)
-          agent_client.wait_until_ready
-          agent_client.update_settings(Bosh::Director::Config.trusted_certs)
-          vm_model.update(:trusted_certs_sha1 => Digest::SHA1.hexdigest(Bosh::Director::Config.trusted_certs))
-        rescue Exception => e
-          @logger.error("Failed to create/contact VM #{vm_model.cid}: #{e.inspect}")
-          VmDeleter.new(@instance, vm_model, @cloud, @logger).delete
-          raise e
-        end
-
-        [vm_model, agent_client]
-      end
-
-      def new_vm_model(new_disk_id)
-        deployment = @instance.job.deployment
-        resource_pool = @instance.job.resource_pool
-
-        Bosh::Director::VmCreator.create(
-          deployment.model,
-          resource_pool.stemcell.model,
-          resource_pool.cloud_properties,
-          @instance.network_settings,
-          [@instance.model.persistent_disk_cid, new_disk_id].compact,
-          resource_pool.env,
-        )
-      end
-    end
-
-    class VmDeleter
-      def initialize(instance, vm_model, cloud, logger)
-        @instance = instance
-        @vm_model = vm_model
-        @cloud = cloud
-        @logger = logger
-      end
-
-      def delete
-        @logger.info('Deleting VM')
-
-        @cloud.delete_vm(@vm_model.cid)
-
-        @instance.model.db.transaction do
-          @instance.model.vm = nil
-          @instance.model.save
-
-          @vm_model.destroy
-        end
-      end
-    end
-
-    class DiskAttacher
-      def initialize(instance, vm_model, agent_client, cloud, logger)
-        @instance = instance
-        @vm_model = vm_model
-        @agent_client = agent_client
-        @cloud = cloud
-        @logger = logger
-      end
-
-      def attach
-        if @instance.model.persistent_disk_cid.nil?
-          @logger.info('Skipping disk attaching')
-          return
-        end
-
-        @cloud.attach_disk(@vm_model.cid, @instance.model.persistent_disk_cid)
-
-        @agent_client.mount_disk(@instance.model.persistent_disk_cid)
-      end
-    end
-
-    class DiskDetacher
-      def initialize(instance, vm_model, agent_client, cloud, logger)
-        @instance = instance
-        @vm_model = vm_model
-        @agent_client = agent_client
-        @cloud = cloud
-        @logger = logger
-      end
-
-      def detach
-        disk_list = @agent_client.list_disk
-        if disk_list.empty?
-          @logger.info('Skipping disk detaching')
-          return
-        end
-
-        if @instance.model.persistent_disk_cid.nil?
-          raise AgentUnexpectedDisk,
-                "`#{@instance}' VM has disk attached but it's not reflected in director DB"
-        end
-
-        @agent_client.unmount_disk(@instance.model.persistent_disk_cid)
-
-        @cloud.detach_disk(@vm_model.cid, @instance.model.persistent_disk_cid)
-      end
-    end
-  end
-end