bosh-director 1.3160.0 → 1.3163.0

data/lib/bosh/director/dns/local_dns_repo.rb

@@ -0,0 +1,20 @@
+module Bosh::Director
+  class LocalDnsRepo
+
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def find(instance_model)
+      instance_model.dns_record_names.to_a
+    end
+
+    def create_or_update(instance_model, dns_record_names)
+      instance_model.update(dns_record_names: dns_record_names)
+    end
+
+    def delete(instance_model)
+      instance_model.update(dns_record_names: [])
+    end
+  end
+end

data/lib/bosh/director/dns/powerdns.rb

@@ -0,0 +1,170 @@
+module Bosh::Director
+  class PowerDns
+    SOA = 'localhost hostmaster@localhost 0 10800 604800 30'
+    TTL_5M = 300
+    TTL_4H = 3600 * 4
+    TTL_5H = 3600 * 5
+
+    def initialize(domain_name, logger)
+      @domain_name = domain_name
+      @logger = logger
+    end
+
+    def find_dns_record(dns_record_name, ip_address)
+      Models::Dns::Record.find(name: dns_record_name, type: 'A', content: ip_address)
+    end
+
+    def find_dns_records_by_ip(ip_address)
+      domain_id = find_domain_id
+      return [] unless domain_id
+
+      Models::Dns::Record.filter(domain_id: domain_id, type: 'A', content: ip_address)
+    end
+
+    def create_or_update_nameserver(ip_address)
+      create_or_update_domain
+      create_or_update_record(@domain_name, SOA, TTL_5M, 'SOA')
+      create_or_update_record(@domain_name, "ns.#{@domain_name}", TTL_4H, 'NS')
+      create_or_update_record("ns.#{@domain_name}", ip_address, TTL_5H, 'A')
+    end
+
+    def create_or_update_dns_records(dns_record_name, ip_address)
+      create_or_update_record(dns_record_name, ip_address, TTL_5M, 'A')
+      update_ptr_record(dns_record_name, ip_address)
+    end
+
+    def find_dns_records_by_pattern(record_pattern)
+      records = Models::Dns::Record.filter(:name.like(record_pattern))
+      records.filter(:domain_id => find_domain_id).all
+    end
+
+    def delete(record_pattern)
+      records = find_dns_records_by_pattern(record_pattern)
+
+      # delete A records and collect all IPs for later
+      ips = []
+      records.each do |record|
+        ips << record.content
+        Models::Dns::Record.filter(:content.like(record.name)).each do |ptr|
+          @logger.info("Deleting reverse DNS record: #{ptr.name} -> #{ptr.content}")
+          ptr.destroy
+        end
+        @logger.info("Deleting DNS record: #{record.name}")
+        record.destroy
+      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
+
+    private
+
+    def create_or_update_domain
+      Models::Dns::Domain.safe_find_or_create(name: @domain_name, type: 'NATIVE')
+    end
+
+    def create_or_update_record(dns_record_name, ip_address, ttl, type)
+      record = Models::Dns::Record.find(name: dns_record_name, type: type)
+      if record.nil?
+        domain = create_or_update_domain
+        record = Models::Dns::Record.new(domain_id: domain.id,
+          name: dns_record_name, type: type,
+          ttl: ttl)
+      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_ptr_record(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: "ns.#{@domain_name}")
+
+      record = Models::Dns::Record.find(content: record_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 = record_name
+      record.change_date = Time.now.to_i
+      record.save
+    end
+
+    def find_domain_id
+      dns_domain = Models::Dns::Domain.find(
+        :name => @domain_name,
+        :type => 'NATIVE',
+      )
+      dns_domain.nil? ? nil : dns_domain.id
+    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, 4)
+    end
+
+    # @param [String] ip IP address
+    # @return [String] reverse dns domain name for an IP
+    def reverse_domain(ip)
+      reverse(ip, 3)
+    end
+
+    def reverse(ip, n)
+      octets = ip.split(/\./)
+      "#{octets[0..(n-1)].reverse.join(".")}.in-addr.arpa"
+    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
+  end
+end

data/lib/bosh/director/errand/job_manager.rb

@@ -2,63 +2,52 @@ module Bosh::Director
   class Errand::JobManager
     # @param [Bosh::Director::DeploymentPlan::Planner] deployment
     # @param [Bosh::Director::DeploymentPlan::Job] job
-    # @param [Bosh::Blobstore::Client] blobstore
+    # @param [Bosh::Clouds] cloud
     # @param [Bosh::Director::EventLog::Log] event_log
     # @param [Logger] logger
-    def initialize(deployment, job, blobstore, event_log, logger)
+    def initialize(deployment, job, cloud, event_log, logger)
       @deployment = deployment
       @job = job
-      @blobstore = blobstore
       @event_log = event_log
       @logger = logger
+      vm_deleter = Bosh::Director::VmDeleter.new(cloud, logger)
+      @disk_manager = DiskManager.new(cloud, logger)
+      @job_renderer = JobRenderer.create
+      @vm_creator = Bosh::Director::VmCreator.new(cloud, logger, vm_deleter, @disk_manager, @job_renderer)
     end
 
-    def prepare
-      @job.bind_unallocated_vms
-      @job.bind_instance_networks
+    def create_missing_vms
+      @vm_creator.create_for_instance_plans(@job.instance_plans_with_missing_vms, @deployment.ip_provider, @event_log)
     end
 
     # Creates/updates all errand job instances
     # @return [void]
     def update_instances
-      dns_binder = DeploymentPlan::DnsBinder.new(@deployment)
-      dns_binder.bind_deployment
-
-      instance_vm_binder = DeploymentPlan::InstanceVmBinder.new(@event_log)
-      instance_vm_binder.bind_instance_vms(@job.instances)
-
-      job_renderer = JobRenderer.new(@job, @blobstore)
-      job_renderer.render_job_instances
-
-      job_updater = JobUpdater.new(@deployment, @job, job_renderer)
+      links_resolver = DeploymentPlan::LinksResolver.new(@deployment, @logger)
+      job_updater = JobUpdater.new(@deployment, @job, links_resolver, @disk_manager)
       job_updater.update
     end
 
     # Deletes all errand job instances
     # @return [void]
     def delete_instances
-      instances = @job.instances.map(&:model).compact
-      if instances.empty?
+      instance_plans = bound_instance_plans
+      if instance_plans.empty?
         @logger.info('No errand instances to delete')
         return
       end
 
       @logger.info('Deleting errand instances')
-      event_log_stage = @event_log.begin_stage('Deleting errand instances', instances.size, [@job.name])
-      instance_deleter = InstanceDeleter.new(@deployment)
-      instance_deleter.delete_instances(instances, event_log_stage)
-
-      deallocate_vms
+      event_log_stage = @event_log.begin_stage('Deleting errand instances', instance_plans.size, [@job.name])
+      dns_manager = DnsManager.create
+      instance_deleter = InstanceDeleter.new(@deployment.ip_provider, dns_manager, @disk_manager)
+      instance_deleter.delete_instance_plans(instance_plans, event_log_stage)
     end
 
     private
 
-    # Deallocates all errand VMs
-    # @return [void]
-    def deallocate_vms
-      @logger.info('Deallocating errand VMs')
-      instance_vm_cids = @job.instances.map { |instance| instance.model.vm.cid }
-      instance_vm_cids.each { |cid| @job.resource_pool.deallocate_vm(cid) }
+    def bound_instance_plans
+      @job.needed_instance_plans.reject { |instance_plan| instance_plan.instance.model.nil? }
     end
   end
 end

data/lib/bosh/director/error_ignorer.rb

@@ -0,0 +1,16 @@
+module Bosh::Director
+  class ErrorIgnorer
+    def initialize(force, logger)
+      @force = force
+      @logger = logger
+    end
+
+    def with_force_check
+      yield
+    rescue => e
+      raise unless @force
+      @logger.warn(e.backtrace.join("\n"))
+      @logger.info('Force deleting is set, ignoring exception')
+    end
+  end
+end

data/lib/bosh/director/errors.rb

@@ -89,10 +89,13 @@ module Bosh::Director
   StemcellAlreadyExists = err(50002)
   StemcellNotFound = err(50003, NOT_FOUND)
   StemcellInUse = err(50004)
-  StemcellSha1DoesNotMatch = err(50005)
+  StemcellAliasAlreadyExists = err(50005)
+  StemcellBothNameAndOS = err(50006)
+  StemcellSha1DoesNotMatch = err(50007)
 
   PackageInvalidArchive = err(60000)
   PackageMissingSourceCode = err(60001)
+  CompiledPackageDeletionFailed = err(60002)
 
   # Models
   DeploymentNotFound = err(70000, NOT_FOUND)
@@ -122,6 +125,7 @@ module Bosh::Director
   JobPackageCollision = err(80011)
   JobInvalidPackageSpec = err(80012)
   JobInvalidLinkSpec = err(80013)
+  JobDuplicateLinkName = err(80014)
 
   ResourceError = err(100001)
   ResourceNotFound = err(100002, NOT_FOUND)
@@ -132,6 +136,7 @@ module Bosh::Director
   PropertyNotFound = err(110003, NOT_FOUND)
 
   CompilationConfigUnknownNetwork = err(120001)
+  CompilationConfigInvalidAvailabilityZone = err(120002)
 
   # Manifest parsing: network section
   NetworkReservationInvalidIp = err(130001)
@@ -144,20 +149,30 @@ module Bosh::Director
   NetworkReservationAlreadyInUse = err(130008)
   NetworkReservationWrongType = err(130009)
   NetworkReservationError = err(130010)
-  NetworkReservationNotEnoughCapacity = err(130010)
+  NetworkReservationNotEnoughCapacity = err(130011)
+  NetworkReservationIpOutsideSubnet = err(130012)
+  NetworkReservationIpReserved = err(130013)
 
   # Manifest parsing: job section
   JobMissingRelease = err(140001)
   JobUnknownRelease = err(140002)
   JobUnknownResourcePool = err(140003)
-  JobInvalidInstanceIndex = err(140004)
-  JobInvalidInstanceState = err(140005)
-  JobInvalidJobState = err(140006)
-  JobMissingNetwork = err(140007)
-  JobInvalidTemplates = err(140008)
-  JobInvalidLifecycle = err(140009)
-  JobUnknownDiskPool = err(140010)
-  JobInvalidPersistentDisk = err(140011)
+  JobUnknownVmType = err(140004)
+  JobUnknownStemcell = err(140005)
+  JobInvalidInstanceIndex = err(140006)
+  JobInvalidInstanceState = err(140007)
+  JobInvalidJobState = err(140008)
+  JobMissingNetwork = err(140009)
+  JobInvalidTemplates = err(140010)
+  JobInvalidLifecycle = err(140011)
+  JobUnknownDiskType = err(140012)
+  JobInvalidPersistentDisk = err(140013)
+  JobMissingLink = err(140014)
+  UnusedProvidedLink = err(140015)
+  JobInvalidAvailabilityZone = err(140016)
+  JobMissingAvailabilityZones = err(140017)
+  JobUnknownAvailabilityZone = err(140018)
+  JobAmbiguousEnv = err(140019)
 
   # Manifest parsing: job networks section
   JobUnknownNetwork = err(150001)
@@ -165,6 +180,10 @@ module Bosh::Director
   JobNetworkInvalidDefault = err(150003)
   JobNetworkMultipleDefaults = err(150004)
   JobNetworkMissingDefault = err(150005)
+  JobNetworkMissingRequiredAvailabilityZone= err(150006)
+  JobStaticIpsFromInvalidAvailabilityZone= err(150007)
+  JobStaticIPNotSupportedOnDynamicNetwork= err(150008)
+  JobInvalidStaticIPs = err(150009)
 
   NetworkOverlappingSubnets = err(160001)
   NetworkInvalidRange = err(160002)
@@ -172,6 +191,10 @@ module Bosh::Director
   NetworkInvalidDns = err(160004)
   NetworkReservedIpOutOfRange = err(160005)
   NetworkStaticIpOutOfRange = err(160006)
+  NetworkSubnetUnknownAvailabilityZone = err(160007)
+  NetworkInvalidProperty = err(160008)
+  NetworkSubnetInvalidAvailabilityZone = err(160009)
+  NetworkInvalidIpRangeFormat = err(160010)
 
   ResourcePoolUnknownNetwork = err(170001)
   ResourcePoolNotEnoughCapacity = err(170002)
@@ -181,18 +204,24 @@ module Bosh::Director
   DeploymentAmbiguousReleaseSpec = err(190001)
   DeploymentDuplicateReleaseName = err(190002)
   DeploymentDuplicateResourcePoolName = err(190003)
-  DeploymentRenamedJobNameStillUsed = err(190004)
-  DeploymentCanonicalJobNameTaken = err(190005)
-  DeploymentCanonicalNetworkNameTaken = err(190006)
-  DeploymentNoNetworks = err(190007)
-  DeploymentCanonicalNameTaken = err(190008)
-  DeploymentInvalidNetworkType = err(190009)
-  DeploymentUnknownTemplate = err(190012)
-  DeploymentDuplicateDiskPoolName = err(190013)
+  DeploymentDuplicateVmTypeName = err(190004)
+  DeploymentRenamedJobNameStillUsed = err(190005)
+  DeploymentCanonicalJobNameTaken = err(190006)
+  DeploymentCanonicalNetworkNameTaken = err(190007)
+  DeploymentNoNetworks = err(190008)
+  DeploymentCanonicalNameTaken = err(190009)
+  DeploymentInvalidNetworkType = err(190010)
+  DeploymentUnknownTemplate = err(190011)
+  DeploymentInvalidDiskSpecification = err(190012)
+  DeploymentDuplicateDiskTypeName = err(190013)
   DeploymentInvalidProperty = err(190014)
   DeploymentNoResourcePools = err(190015)
+  DeploymentInvalidLink = err(190016)
+  DeploymentDuplicateAvailabilityZoneName = err(190017)
+  DeploymentInvalidMigratedFromJob = err(190018)
+  DeploymentInvalidResourceSpecification = err(190019)
 
-  DiskPoolInvalidDiskSize = err(200001)
+  DiskTypeInvalidDiskSize = err(200001)
 
   CloudDiskNotAttached = err(390001)
   CloudDiskMissing = err(390002)
@@ -218,7 +247,6 @@ module Bosh::Director
 
   DnsInvalidCanonicalName = err(420001)
 
-  PackageCompilationNetworkNotReserved = err(430001)
   PackageCompilationNotEnoughWorkersForReuse = err(430002)
   PackageCompilationNotFound = err(430003)
 
@@ -232,4 +260,7 @@ module Bosh::Director
 
   # Run errand errors
   RunErrandError = err(510000)
+
+  #Deleting Disk
+  DeletingPersistentDiskError = err(520000)
 end

data/lib/bosh/director/event_log.rb

@@ -112,6 +112,12 @@ module Bosh::Director
       end
     end
 
+    class NullStage
+      def advance_and_track(_, &blk)
+        blk.call
+      end
+    end
+
     class Task
       def initialize(stage, name, index)
         @stage = stage

data/lib/bosh/director/instance_deleter.rb

@@ -1,107 +1,79 @@
 module Bosh::Director
   # Coordinates the safe deletion of an instance and all associates resources.
   class InstanceDeleter
-    include DnsHelper
 
-    def initialize(deployment_plan)
-      @deployment_plan = deployment_plan
+    def initialize(ip_provider, dns_manager, disk_manager, options={})
+      @ip_provider = ip_provider
+      @dns_manager = dns_manager
+      @disk_manager = disk_manager
       @cloud = Config.cloud
       @logger = Config.logger
       @blobstore = App.instance.blobstores.blobstore
+
+      @force = options.fetch(:force, false)
     end
 
-    # Deletes a list of instances
-    # @param [Array<Models::Instance>] instances list of instances to delete
-    # @param [Hash] options optional list of options controlling concurrency
-    # @return [void]
-    def delete_instances(instances, event_log_stage, options = {})
-      max_threads = options[:max_threads] || Config.max_threads
-      ThreadPool.new(:max_threads => max_threads).wrap do |pool|
-        instances.each do |instance|
-          pool.process { delete_instance(instance, event_log_stage) }
+    def delete_instance_plan(instance_plan, event_log_stage)
+      instance_model = instance_plan.new? ? instance_plan.instance.model : instance_plan.existing_instance
+
+      @logger.info("Deleting instance '#{instance_model}'")
+
+      event_log_stage.advance_and_track(instance_model.to_s) do
+
+        error_ignorer.with_force_check do
+          stop(instance_plan)
         end
-      end
-    end
 
-    # Deletes a single instance and attached persistent disks
-    # @param [Models::Instance] instance instance to delete
-    # @return [void]
-    def delete_instance(instance, event_log_stage)
-      vm = instance.vm
-      @logger.info("Delete unneeded instance: #{vm.cid}")
-
-      event_log_stage.advance_and_track(vm.cid) do
-        drain(vm.agent_id)
-        @cloud.delete_vm(vm.cid)
-        delete_snapshots(instance)
-        delete_persistent_disks(instance.persistent_disks)
-        delete_dns(instance.job, instance.index)
-
-        RenderedJobTemplatesCleaner.new(instance, @blobstore, @logger).clean_all
-
-        vm.db.transaction do
-          instance.destroy
-          vm.destroy
+        vm_deleter.delete_for_instance_plan(instance_plan)
+
+        unless instance_model.compilation
+          error_ignorer.with_force_check do
+            @disk_manager.delete_persistent_disks(instance_model)
+          end
+
+          error_ignorer.with_force_check do
+            @dns_manager.delete_dns_for_instance(instance_model)
+          end
+
+          error_ignorer.with_force_check do
+            RenderedJobTemplatesCleaner.new(instance_model, @blobstore, @logger).clean_all
+          end
         end
+
+        instance_plan.network_plans.each do |network_plan|
+          reservation = network_plan.reservation
+          @ip_provider.release(reservation) if reservation.reserved?
+        end
+        instance_plan.release_all_network_plans
+
+        instance_model.destroy
       end
     end
 
-    # Drain the instance
-    # @param [String] agent_id agent id
-    # @return [void]
-    def drain(agent_id)
-      agent = AgentClient.with_defaults(agent_id)
-
-      drain_time = agent.drain("shutdown")
-      while drain_time < 0
-        drain_time = drain_time.abs
-        begin
-          @logger.info("Drain - check back in #{drain_time} seconds")
-          sleep(drain_time)
-          drain_time = agent.drain("status")
-        rescue => e
-          @logger.warn("Failed to check drain-status: #{e.inspect}")
-          raise if e.kind_of?(Bosh::Director::TaskCancelled)
-          break
+    def delete_instance_plans(instance_plans, event_log_stage, options = {})
+      max_threads = options[:max_threads] || Config.max_threads
+      ThreadPool.new(:max_threads => max_threads).wrap do |pool|
+        instance_plans.each do |instance_plan|
+          pool.process { delete_instance_plan(instance_plan, event_log_stage) }
         end
       end
-
-      sleep(drain_time)
-      agent.stop
     end
 
-    def delete_snapshots(instance)
-      snapshots = instance.persistent_disks.map { |disk| disk.snapshots }.flatten
-      Bosh::Director::Api::SnapshotManager.delete_snapshots(snapshots)
+    private
+
+    def stop(instance_plan)
+      stopper = Stopper.new(instance_plan, 'stopped', Config, @logger)
+      stopper.stop
     end
 
-    # Delete persistent disks
-    # @param [Array<Model::PersistentDisk>] persistent_disks disks
-    # @return [void]
-    def delete_persistent_disks(persistent_disks)
-      persistent_disks.each do |disk|
-        @logger.info("Deleting disk: `#{disk.disk_cid}', " +
-                     "#{disk.active ? "active" : "inactive"}")
-        begin
-          @cloud.delete_disk(disk.disk_cid)
-        rescue Bosh::Clouds::DiskNotFound => e
-          @logger.warn("Disk not found: #{disk.disk_cid}")
-          raise if disk.active
-        end
-        disk.destroy
-      end
+    # FIXME: why do we hate dependency injection?
+    def error_ignorer
+      @error_ignorer ||= ErrorIgnorer.new(@force, @logger)
     end
 
-    # Deletes the DNS records
-    # @param [String] job job name
-    # @param [Numeric] index job index
-    # @return [void]
-    def delete_dns(job, index)
-      if Config.dns_enabled?
-        record_pattern = [index, canonical(job), "%",
-                          @deployment_plan.canonical_name, dns_domain_name].join(".")
-        delete_dns_records(record_pattern, @deployment_plan.dns_domain.id)
-      end
+    # FIXME: why do we hate dependency injection?
+    def vm_deleter
+      @vm_deleter ||= VmDeleter.new(@cloud, @logger, {force: @force})
     end
   end
 end