bosh-director 1.3160.0 → 1.3163.0

data/lib/bosh/director/jobs/delete_deployment.rb

@@ -1,7 +1,6 @@
 module Bosh::Director
   module Jobs
     class DeleteDeployment < BaseJob
-      include DnsHelper
       include LockHelper
 
       @queue = :normal
@@ -12,174 +11,31 @@ module Bosh::Director
 
       def initialize(deployment_name, options = {})
         @deployment_name = deployment_name
-        @force = options["force"]
-        @keep_snapshots = options["keep_snapshots"]
+        @force = options['force']
+        @keep_snapshots = options['keep_snapshots']
         @cloud = Config.cloud
         @deployment_manager = Api::DeploymentManager.new
-        @blobstore = App.instance.blobstores.blobstore
       end
 
       def perform
         logger.info("Deleting: #{@deployment_name}")
 
-        deployment = find_deployment(@deployment_name)
-
-        logger.info("Acquiring deployment lock: #{deployment.name}")
-
         with_deployment_lock(@deployment_name) do
-          # Make sure it wasn't deleted
-          deployment = find_deployment(@deployment_name)
-
-          ThreadPool.new(:max_threads => Config.max_threads).wrap do |pool|
-            delete_instances(deployment, pool)
-            pool.wait
-            delete_vms(deployment, pool)
-          end
+          deployment_model = @deployment_manager.find_by_name(@deployment_name)
 
-          event_log.begin_stage("Removing deployment artifacts", 3)
-          track_and_log("Detach stemcells") do
-            deployment.remove_all_stemcells
-          end
+          ip_provider = DeploymentPlan::IpProviderFactory.new(true, logger)
 
-          track_and_log("Detaching releases") do
-            deployment.remove_all_release_versions
-          end
+          dns_manager = DnsManager.create
+          disk_manager = DiskManager.new(@cloud, logger)
+          instance_deleter = InstanceDeleter.new(ip_provider, dns_manager, disk_manager, force: @force)
+          deployment_deleter = DeploymentDeleter.new(event_log, logger, dns_manager, Config.max_threads)
 
-          event_log.begin_stage("Deleting properties",
-                                 deployment.properties.count)
-          logger.info("Deleting deployment properties")
-          deployment.properties.each do |property|
-            event_log.track(property.name) do
-              property.destroy
-            end
-          end
+          vm_deleter = Bosh::Director::VmDeleter.new(@cloud, logger, force: @force)
+          deployment_deleter.delete(deployment_model, instance_deleter, vm_deleter)
 
-          track_and_log("Delete DNS records") do
-            delete_dns(@deployment_name)
-          end
-
-          track_and_log("Destroy deployment") do
-            deployment.destroy
-          end
           "/deployments/#{@deployment_name}"
         end
       end
-
-      def find_deployment(name)
-        @deployment_manager.find_by_name(name)
-      end
-
-      def delete_instances(deployment, pool)
-        instances = deployment.job_instances
-        event_log.begin_stage("Deleting instances", instances.count)
-
-        instances.each do |instance|
-          pool.process do
-            desc = "#{instance.job}/#{instance.index}"
-            event_log.track(desc) do
-              logger.info("Deleting #{desc}")
-              delete_instance(instance)
-            end
-          end
-        end
-      end
-
-      def delete_vms(deployment, pool)
-        vms = deployment.vms
-        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}")
-              delete_vm(vm)
-            end
-          end
-        end
-      end
-
-      def delete_instance(instance)
-        desc = "#{instance.job}/#{instance.index}"
-        with_thread_name("delete_instance(#{desc})") do
-          logger.info("Deleting instance: #{desc}")
-
-          vm = instance.vm
-
-          if vm && vm.agent_id
-            ignoring_errors_when_forced do
-              agent = AgentClient.with_defaults(vm.agent_id)
-              agent.stop
-            end
-          end
-
-          instance.persistent_disks.each do |disk|
-            if disk.active && vm && vm.cid && disk.disk_cid
-              if vm.agent_id
-                ignoring_errors_when_forced do
-                  agent = AgentClient.with_defaults(vm.agent_id)
-                  agent.unmount_disk(disk.disk_cid)
-                end
-              end
-
-              ignoring_errors_when_forced do
-                # If persistent disk has been mounted but
-                # clean_shutdown above did not unmount it
-                # properly (i.e. for wedged deployment),
-                # detach_disk might hang indefinitely.
-                # Right now it's up to cloudcheck handle
-                # that but 'force' might be added to CPI
-                # in the future.
-                @cloud.detach_disk(vm.cid, disk.disk_cid)
-              end
-            end
-
-            if disk.disk_cid
-              ignoring_errors_when_forced do
-                delete_snapshots(disk)
-                @cloud.delete_disk(disk.disk_cid)
-              end
-            end
-
-            disk.destroy
-          end
-
-          ignoring_errors_when_forced do
-            RenderedJobTemplatesCleaner.new(instance, @blobstore, @logger).clean_all
-          end
-
-          instance.destroy
-
-          delete_vm(vm) if vm
-        end
-      end
-
-      def delete_snapshots(disk)
-        @keep_snapshots ? disk.snapshots.each(&:delete) : Api::SnapshotManager.delete_snapshots(disk.snapshots)
-      end
-
-      def delete_vm(vm)
-        if vm.cid
-          ignoring_errors_when_forced do
-            @cloud.delete_vm(vm.cid)
-          end
-        end
-        vm.destroy
-      end
-
-      def delete_dns(name)
-        if Config.dns_enabled?
-          record_pattern = ["%", canonical(name), dns_domain_name].join(".")
-          delete_dns_records(record_pattern)
-        end
-      end
-
-      def ignoring_errors_when_forced
-        yield
-      rescue => e
-        raise unless @force
-        logger.warn(e.backtrace.join("\n"))
-        logger.info("Force deleting is set, ignoring exception")
-      end
     end
   end
 end

data/lib/bosh/director/jobs/delete_deployment_snapshots.rb

@@ -31,4 +31,4 @@ module Bosh::Director
       end
     end
   end
-end
+end

data/lib/bosh/director/jobs/delete_orphan_disks.rb

@@ -0,0 +1,44 @@
+module Bosh::Director
+  module Jobs
+    class DeleteOrphanDisks < BaseJob
+
+      @queue = :normal
+
+      def self.job_type
+        :delete_orphan_disks
+      end
+
+      def self.enqueue(username, orphan_disk_cids, job_queue)
+        persistent_disk_cids = orphan_disk_cids.select do |disk_cid|
+          Bosh::Director::Models::PersistentDisk.where(disk_cid: disk_cid).any?
+        end
+        if persistent_disk_cids.any?
+          raise DeletingPersistentDiskError, "Deleting persistent disk is not supported: #{persistent_disk_cids}"
+        end
+
+        job_queue.enqueue(username, Jobs::DeleteOrphanDisks, 'delete orphan disks', [orphan_disk_cids])
+      end
+
+      def initialize(orphan_disk_cids)
+        @orphan_disk_cids = orphan_disk_cids
+        @disk_manager = Bosh::Director::DiskManager.new(Config.cloud, Config.logger)
+      end
+
+      def perform
+        event_log.begin_stage('Deleting orphaned disks', @orphan_disk_cids.count)
+
+        ThreadPool.new(:max_threads => Config.max_threads).wrap do |pool|
+          @orphan_disk_cids.each do |orphan_disk_cid|
+            pool.process do
+              event_log.track("Deleting orphaned disk #{orphan_disk_cid}") do
+                @disk_manager.delete_orphan_disk_by_disk_cid(orphan_disk_cid)
+              end
+            end
+          end
+        end
+
+        "orphaned disk(s) #{@orphan_disk_cids.join(', ')} deleted"
+      end
+    end
+  end
+end

data/lib/bosh/director/jobs/delete_release.rb

@@ -1,5 +1,3 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
 module Bosh::Director
   module Jobs
     class DeleteRelease < BaseJob
@@ -13,212 +11,37 @@ module Bosh::Director
 
       def initialize(name, options = {})
         @name = name
-        @blobstore = options.fetch(:blobstore) { App.instance.blobstores.blobstore }
-        @errors = []
-        @force = !!options["force"]
-        @version = options["version"]
-        @release_manager = Api::ReleaseManager.new
-      end
-
-      def delete_release_version(release_version)
-        release = release_version.release
-
-        packages_to_keep = []
-        packages_to_delete = []
-        templates_to_keep = []
-        templates_to_delete = []
-
-        # We don't delete packages inside this loop b/c Sequel will also delete
-        # them from packages collection we're iterating on which will lead to
-        # skipping some packages
-        release_version.packages.each do |package|
-          if package.release_versions == [ release_version ]
-            packages_to_delete << package
-          else
-            packages_to_keep << package
-          end
-        end
-
-        release_version.templates.each do |template|
-          if template.release_versions == [ release_version ]
-            templates_to_delete << template
-          else
-            templates_to_keep << template
-          end
-        end
-
-        event_log.begin_stage("Deleting packages", packages_to_delete.count)
-        packages_to_delete.each do |package|
-          track_and_log("#{package.name}/#{package.version}") do
-            logger.info("Package #{package.name}/#{package.version} " +
-                        "is only used by this release version " +
-                        "and will be deleted")
-            delete_package(package)
-          end
-        end
-
-        packages_to_keep.each do |package|
-          logger.info("Keeping package #{package.name}/#{package.version} " +
-                      "as it is used by other release versions")
-          package.remove_release_version(release_version)
-        end
-
-        event_log.begin_stage("Deleting jobs", templates_to_delete.count)
-        templates_to_delete.each do |template|
-          track_and_log("#{template.name}/#{template.version}") do
-            logger.info("Template #{template.name}/#{template.version} " +
-                        "is only used by this release version " +
-                        "and will be deleted")
-            delete_template(template)
-          end
-        end
+        @force = !!options['force']
+        @version = options['version']
 
-        templates_to_keep.each do |template|
-          logger.info("Keeping job " +
-                      "#{template.name}/#{template.version} as it is used " +
-                      "by other release versions")
-          template.remove_release_version(release_version)
-        end
-
-        logger.info("Remove all deployments in release version")
-        release_version.remove_all_deployments
-
-        if @errors.empty? || @force
-          release_version.destroy
-        end
-
-        if release.versions.empty?
-          delete_release(release)
-        end
-      end
-
-      def delete_release(release)
-        event_log.begin_stage("Deleting packages", release.packages.count)
-        release.packages.each do |package|
-          track_and_log("#{package.name}/#{package.version}") do
-            delete_package(package)
-          end
-        end
-
-        event_log.begin_stage("Deleting jobs", release.templates.count)
-        release.templates.each do |template|
-          track_and_log("#{template.name}/#{template.version}") do
-            delete_template(template)
-          end
-        end
-
-        if @errors.empty? || @force
-          event_log.begin_stage("Deleting release versions",
-                                release.versions.count)
-
-          release.versions.each do |release_version|
-            track_and_log("#{release.name}/#{release_version.version}") do
-              release_version.destroy
-            end
-          end
-
-          release.destroy
-        end
-      end
-
-      def delete_package(package)
-        compiled_packages = package.compiled_packages
-
-        logger.info("Deleting package #{package.name}/#{package.version}")
-
-        compiled_packages.each do |compiled_package|
-          stemcell = compiled_package.stemcell
-          logger.info("Deleting compiled package " +
-                      "(#{compiled_package.blobstore_id}) " +
-                      "#{package.name}/#{package.version} " +
-                      "for #{stemcell.name}/#{stemcell.version}")
-
-          if delete_blobstore_id(compiled_package.blobstore_id)
-            compiled_package.destroy
-          end
-        end
-
-        if delete_blobstore_id(package.blobstore_id, true)
-          package.remove_all_release_versions
-          package.destroy
-        end
-      end
-
-      def delete_template(template)
-        logger.info("Deleting job: #{template.name}/#{template.version}")
-
-        if delete_blobstore_id(template.blobstore_id)
-          template.remove_all_release_versions
-          template.destroy
-        end
+        blobstore = options.fetch(:blobstore) { App.instance.blobstores.blobstore }
+        blob_deleter = Helpers::BlobDeleter.new(blobstore, logger)
+        compiled_package_deleter = Helpers::CompiledPackageDeleter.new(blob_deleter, logger)
+        package_deleter = Helpers::PackageDeleter.new(compiled_package_deleter, blob_deleter, logger)
+        template_deleter = Helpers::TemplateDeleter.new(blob_deleter, logger)
+        release_deleter = Helpers::ReleaseDeleter.new(package_deleter, template_deleter, event_log, logger)
+        release_version_deleter =
+          Helpers::ReleaseVersionDeleter.new(release_deleter, package_deleter, template_deleter, logger, event_log)
+        release_manager = Api::ReleaseManager.new
+        @name_version_release_deleter = Helpers::NameVersionReleaseDeleter.new(release_deleter, release_manager, release_version_deleter, logger)
       end
 
       def perform
-        logger.info("Processing delete release")
+        logger.info('Processing delete release')
 
-        with_release_lock(@name, :timeout => 10) do
-          logger.info("Looking up release: #{@name}")
-          release = @release_manager.find_by_name(@name)
-          logger.info("Found release: #{release.name}")
+        errors = nil
 
-          if @version
-            logger.info("Looking up release version `#{release.name}/#{@version}'")
-            release_version = @release_manager.find_version(release, @version)
-            # found version may be different than the requested version, due to version formatting
-            logger.info("Found release version: `#{release.name}/#{release_version.version}'")
-            logger.info("Checking for any deployments still using " +
-                         "this particular release version")
-
-            deployments = release_version.deployments
-
-            unless deployments.empty?
-              names = deployments.map{ |d| d.name }.join(", ")
-              raise ReleaseVersionInUse,
-                    "ReleaseVersion `#{release.name}/#{release_version.version}' is still in use by: #{names}"
-            end
-
-            delete_release_version(release_version)
-          else
-            logger.info("Checking for any deployments still using the release")
-            deployments = release.versions.map { |version|
-              version.deployments
-            }.flatten.uniq
-
-            unless deployments.empty?
-              names = deployments.map { |d| d.name }.join(", ")
-              raise ReleaseInUse,
-                    "Release `#{release.name}' is still in use by: #{names}"
-            end
-
-            delete_release(release)
-          end
+        with_release_lock(@name, :timeout => 10) do
+          errors = @name_version_release_deleter.find_and_delete_release(@name, @version, @force)
         end
 
-        unless @errors.empty?
-          errors = @errors.map { |e| e.to_s }.join(", ")
-          raise ReleaseDeleteFailed, "Can't delete release: #{errors}"
+        unless errors.empty?
+          error_strings = errors.map { |e| e.to_s }.join(', ')
+          raise ReleaseDeleteFailed, "Can't delete release: #{error_strings}"
         end
 
         "/release/#{@name}"
       end
-
-      def delete_blobstore_id(blobstore_id, nil_id_allowed = false)
-        if blobstore_id.nil? && nil_id_allowed
-          return true
-        end
-
-        deleted = false
-        begin
-          @blobstore.delete(blobstore_id)
-          deleted = true
-        rescue Exception => e
-          logger.warn("Could not delete from blobstore: #{e}\n " + e.backtrace.join("\n"))
-          @errors << e
-        end
-
-        return deleted || @force
-      end
-
     end
   end
 end