bosh-director 1.5.0.pre.1113

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

@@ -0,0 +1,66 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Jobs
+    class BaseJob
+
+      def self.job_type
+        raise NotImplementedError.new('Subclasses must return a symbol representing type')
+      end
+
+      def self.perform(task_id, *args)
+        Bosh::Director::JobRunner.new(self, task_id).run(*args)
+      end
+
+      attr_accessor :task_id
+
+      def logger
+        @logger ||= Config.logger
+      end
+
+      def event_log
+        @event_log ||= Config.event_log
+      end
+
+      def result_file
+        @result_file ||= Config.result
+      end
+
+      # @return [Boolean] Has task been cancelled?
+      def task_cancelled?
+        return false if task_id.nil?
+        task = task_manager.find_task(task_id)
+        task && (task.state == "cancelling" || task.state == "timeout")
+      end
+
+      def task_checkpoint
+        if task_cancelled?
+          raise TaskCancelled, "Task #{task_id} cancelled"
+        end
+      end
+
+      def begin_stage(stage_name, n_steps)
+        event_log.begin_stage(stage_name, n_steps)
+        logger.info(stage_name)
+      end
+
+      def track_and_log(task, log = true)
+        event_log.track(task) do |ticker|
+          logger.info(task) if log
+          yield ticker if block_given?
+        end
+      end
+
+      def single_step_stage(stage_name)
+        begin_stage(stage_name, 1)
+        track_and_log(stage_name, false) { yield }
+      end
+
+      private
+
+      def task_manager
+        @task_manager ||= Api::TaskManager.new
+      end
+    end
+  end
+end

data/lib/bosh/director/jobs/cloud_check/apply_resolutions.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Jobs
+    module CloudCheck
+      class ApplyResolutions < BaseJob
+        include LockHelper
+
+        @queue = :normal
+
+        def self.job_type
+          :cck_apply
+        end
+
+        # @param [String] deployment_name Deployment name
+        # @param [Hash] resolutions Problem resolutions
+        def initialize(deployment_name, resolutions)
+          @deployment_manager = Api::DeploymentManager.new
+          @deployment = @deployment_manager.find_by_name(deployment_name)
+
+          unless resolutions.kind_of?(Hash)
+            raise CloudcheckInvalidResolutionFormat,
+                  "Invalid format for resolutions, Hash expected, #{resolutions.class} is given"
+          end
+
+          # Normalizing problem ids
+          @resolutions =
+            resolutions.inject({}) { |hash, (problem_id, solution_name)|
+              hash[problem_id.to_s] = solution_name
+              hash
+            }
+
+          @problem_resolver = ProblemResolver.new(@deployment)
+        end
+
+        def perform
+          with_deployment_lock(@deployment) do
+            count = @problem_resolver.apply_resolutions(@resolutions)
+            "#{count} resolved"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/bosh/director/jobs/cloud_check/scan.rb

@@ -0,0 +1,38 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Jobs
+    module CloudCheck
+      class Scan < BaseJob
+        include LockHelper
+
+        @queue = :normal
+
+        def self.job_type
+          :cck_scan
+        end
+
+        # @param [String] deployment_name Deployment name
+        def initialize(deployment_name)
+          @deployment_manager = Api::DeploymentManager.new
+          @deployment = @deployment_manager.find_by_name(deployment_name)
+        end
+
+        def perform
+          begin
+            with_deployment_lock(@deployment, :timeout => 0) do
+              scanner = ProblemScanner.new(@deployment)
+              scanner.reset
+              scanner.scan_vms
+              scanner.scan_disks
+
+              "scan complete"
+            end
+          rescue Lock::TimeoutError
+            raise "Unable to get deployment lock, maybe a deployment is in progress. Try again later."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bosh/director/jobs/cloud_check/scan_and_fix.rb

@@ -0,0 +1,73 @@
+# This job is used by the resurrector health monitor plugin, to notify the director that
+# it needs to scan the job(s) for problems (only unresponsive agents) and then try to
+# automatically try to fix it by recreating the job.
+module Bosh::Director
+  module Jobs
+    module CloudCheck
+      class ScanAndFix < BaseJob
+        include LockHelper
+
+        attr_reader :filtered_jobs
+
+        @queue = :normal
+
+        def self.job_type
+          :cck_scan_and_fix
+        end
+
+        def initialize(deployment_name, jobs, fix_stateful_jobs=false)
+          @deployment_manager = Api::DeploymentManager.new
+          @instance_manager = Bosh::Director::Api::InstanceManager.new
+          @deployment = @deployment_manager.find_by_name(deployment_name)
+          @jobs = jobs # {j1 => [i1, i2, ...], j2 => [i1, i2, ...]}
+          @fix_stateful_jobs = fix_stateful_jobs
+        end
+
+        def perform
+          jobs = filtered_jobs
+
+          begin
+            with_deployment_lock(@deployment, :timeout => 0) do
+
+              scanner = ProblemScanner.new(@deployment)
+              scanner.reset(jobs)
+              scanner.scan_vms(jobs)
+
+              resolver = ProblemResolver.new(@deployment)
+              resolver.apply_resolutions(resolutions(jobs))
+
+              "scan and fix complete"
+            end
+          rescue Lock::TimeoutError
+            raise "Unable to get deployment lock, maybe a deployment is in progress. Try again later."
+          end
+        end
+
+        def resolutions(jobs)
+          all_resolutions = {}
+          jobs.each do |job, index|
+            instance = @instance_manager.find_by_name(@deployment.name, job, index)
+            next if instance.resurrection_paused
+            problems = Models::DeploymentProblem.filter(deployment: @deployment, resource_id: instance.vm.id, state: 'open')
+            problems.each do |problem|
+              if problem.type == 'unresponsive_agent' || problem.type == 'missing_vm'
+                all_resolutions[problem.id.to_s] = :recreate_vm
+              end
+            end
+          end
+
+          all_resolutions
+        end
+
+        def filtered_jobs
+          return @jobs if @fix_stateful_jobs
+
+          @jobs.reject do |job, index|
+            instance = @instance_manager.find_by_name(@deployment.name, job, index)
+            instance.persistent_disk
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Bosh::Director
+  module Jobs
+    class CreateSnapshot < BaseJob
+
+      @queue = :normal
+
+      def self.job_type
+        :create_snapshot
+      end
+
+      def initialize(instance_id, options)
+        @instance = Bosh::Director::Api::InstanceManager.new.find_instance(instance_id)
+        @options = options
+      end
+
+      def perform
+        logger.info("taking snapshot of: #{@instance.job}/#{@instance.index} (#{@instance.vm.cid})")
+        snapshot_cids = Bosh::Director::Api::SnapshotManager.take_snapshot(@instance, @options)
+        "snapshot(s) #{snapshot_cids.join(', ')} created"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,183 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module Jobs
+    class DeleteDeployment < BaseJob
+      include DnsHelper
+      include LockHelper
+
+      @queue = :normal
+
+      def self.job_type
+        :delete_deployment
+      end
+
+      def initialize(deployment_name, options = {})
+        @deployment_name = deployment_name
+        @force = options["force"]
+        @keep_snapshots = options["keep_snapshots"]
+        @cloud = Config.cloud
+        @deployment_manager = Api::DeploymentManager.new
+      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
+
+          event_log.begin_stage("Removing deployment artifacts", 3)
+          track_and_log("Detach stemcells") do
+            deployment.remove_all_stemcells
+          end
+
+          track_and_log("Detaching releases") do
+            deployment.remove_all_release_versions
+          end
+
+          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
+
+          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.new(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.new(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
+
+          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

@@ -0,0 +1,34 @@
+module Bosh::Director
+  module Jobs
+    class DeleteDeploymentSnapshots < BaseJob
+      @queue = :normal
+
+      attr_reader :deployment
+
+      def self.job_type
+        :delete_deployment_snapshots
+      end
+
+      def initialize(deployment_name)
+        @deployment = deployment_manager.find_by_name(deployment_name)
+      end
+
+      def deployment_manager
+        @deployment_manager ||= Bosh::Director::Api::DeploymentManager.new
+      end
+
+      def perform
+        logger.info("deleting snapshots of deployment: #{deployment.name}")
+        deployment.job_instances.each do |instance|
+          snapshots = instance.persistent_disks.map { |disk| disk.snapshots }.flatten
+          if snapshots.any?
+            logger.info("deleting snapshots of: #{instance.job}/#{instance.index} (#{instance.vm.cid})")
+            Bosh::Director::Api::SnapshotManager.delete_snapshots(snapshots)
+          end
+        end
+
+        "snapshots of deployment `#{deployment.name}' deleted"
+      end
+    end
+  end
+end