bosh-director 1.5.0.pre.1113

data/lib/bosh/director/ip_util.rb

@@ -0,0 +1,67 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  module IpUtil
+
+    def each_ip(ranges, &block)
+      if ranges.kind_of?(Array)
+        ranges.each do |range|
+          process_range(range, &block)
+        end
+      elsif ranges.kind_of?(String)
+        process_range(ranges, &block)
+      elsif !ranges.nil?
+        raise ArgumentError,
+              "Unknown range type, must be list or a string: " +
+              "#{ranges.class} #{ranges}"
+      end
+    end
+
+    def process_range(range)
+      parts = range.split("-")
+      parts.each { |part| part.strip! }
+      if parts.size == 1
+        range    = NetAddr::CIDR.create(parts[0])
+        first_ip = range.first(:Objectify => true).to_i
+        last_ip  = range.last(:Objectify => true).to_i
+        (first_ip .. last_ip).each do |ip|
+          yield ip
+        end
+      elsif parts.size == 2
+        first_ip = NetAddr::CIDR.create(parts[0])
+        last_ip  = NetAddr::CIDR.create(parts[1])
+        raise ArgumentError unless first_ip.size == 1
+        raise ArgumentError unless last_ip.size == 1
+        (first_ip.to_i .. last_ip.to_i).each do |ip|
+          yield ip
+        end
+      else
+        raise ArgumentError
+      end
+    end
+
+    def ip_to_i(ip)
+      unless ip.kind_of?(Integer)
+        unless ip.kind_of?(NetAddr::CIDR)
+          ip = NetAddr::CIDR.create(ip)
+        end
+        ip = ip.to_i
+      end
+      ip
+    end
+
+    def ip_to_netaddr(ip)
+      unless ip.kind_of?(NetAddr::CIDR)
+        ip = NetAddr::CIDR.create(ip)
+      end
+      ip
+    end
+
+    # @param [Integer] ip Integer IP representation
+    # @return [String] Human-readable IP representation
+    def format_ip(ip)
+      ip_to_netaddr(ip).ip
+    end
+
+  end
+end

data/lib/bosh/director/job_queue.rb

@@ -0,0 +1,16 @@
+module Bosh::Director
+
+  # Abstracts the resque system.
+
+  class JobQueue
+    include Api::TaskHelper
+
+    def enqueue(user, job_class, description, params)
+      task = create_task(user, job_class.job_type, description)
+
+      Resque.enqueue(job_class, task.id, *params)
+
+      task
+    end
+  end
+end

data/lib/bosh/director/job_runner.rb

@@ -0,0 +1,162 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+  class JobRunner
+
+    # @param [Class] job_class Job class to instantiate and run
+    # @param [Integer] task_id Existing task id
+    def initialize(job_class, task_id)
+      unless job_class.kind_of?(Class) &&
+        job_class <= Jobs::BaseJob
+        raise DirectorError, "Invalid director job class `#{job_class}'"
+      end
+
+      task_manager = Bosh::Director::Api::TaskManager.new
+
+      @job_class = job_class
+      @task = task_manager.find_task(task_id)
+
+      setup_logging
+    end
+
+    # Runs director job
+    def run(*args)
+      Config.current_job = nil
+
+      @debug_logger.info("Starting task: #{@task.id}")
+      started_at = Time.now
+
+      with_thread_name("task:#{@task.id}") { perform_job(*args) }
+
+      duration = Duration.duration(Time.now - started_at)
+      @debug_logger.info("Task took #{duration} to process.")
+    end
+
+    # Task checkpoint: updates timestamp so running task isn't marked as
+    # timed out.
+    # @return [void]
+    def checkpoint
+      @task.update(:checkpoint_time => Time.now)
+    end
+
+    private
+
+    # Sets up job logging.
+    # @return [void]
+    def setup_logging
+      # It's up to a caller to set up task output directory
+      unless @task.output && File.directory?(@task.output)
+        raise DirectorError,
+              "Task directory `#{@task.output}' is missing"
+      end
+
+      debug_log = File.join(@task.output, "debug")
+      event_log = File.join(@task.output, "event")
+      result_log = File.join(@task.output, "result")
+
+      @debug_logger = Logger.new(debug_log)
+      @debug_logger.level = Config.logger.level
+      @debug_logger.formatter = ThreadFormatter.new
+
+      Config.event_log = EventLog.new(event_log)
+      Config.result = TaskResultFile.new(result_log)
+      Config.logger = @debug_logger
+
+      Config.db.logger = @debug_logger
+
+      if Config.dns_enabled?
+        Config.dns_db.logger = @debug_logger
+      end
+
+      cpi_log = File.join(@task.output, "cpi")
+      Config.cloud_options["properties"] ||= {}
+      Config.cloud_options["properties"]["cpi_log"] = cpi_log
+    end
+
+    # Instantiates and performs director job.
+    # @param [Array] args Opaque list of job arguments that will be used to
+    #   instantiate the new job object.
+    # @return [void]
+    def perform_job(*args)
+      @debug_logger.info("Creating job")
+
+      job = @job_class.new(*args)
+      Config.current_job = job
+
+      job.task_id = @task.id
+      job.task_checkpoint # cancelled in the queue?
+
+      run_checkpointing
+
+      @debug_logger.info("Performing task: #{@task.id}")
+
+      @task.state = :processing
+      @task.timestamp = Time.now
+      @task.checkpoint_time = Time.now
+      @task.save
+
+      result = job.perform
+
+      @debug_logger.info("Done")
+      finish_task(:done, result)
+
+    rescue Bosh::Director::TaskCancelled => e
+      log_exception(e)
+      @debug_logger.info("Task #{@task.id} cancelled")
+      finish_task(:cancelled, "task cancelled")
+    rescue Exception => e
+      log_exception(e)
+      @debug_logger.error("#{e}\n#{e.backtrace.join("\n")}")
+      finish_task(:error, e)
+    end
+
+    # Spawns a thread that periodically updates task checkpoint time.
+    # There is no need to kill this thread as job execution lifetime is the
+    # same as Resque worker process lifetime.
+    # @return [Thread] Checkpoint thread
+    def run_checkpointing
+      Thread.new do
+        with_thread_name("task:#{@task.id}-checkpoint") do
+          while true
+            sleep(Config.task_checkpoint_interval)
+            checkpoint
+          end
+        end
+      end
+    end
+
+    # Truncates string to fit task result length
+    # @param [String] string The original string
+    # @param [Integer] len Desired string length
+    # @return [String] Truncated string
+    def truncate(string, len = 128)
+      stripped = string.strip[0..len]
+      if stripped.length > len
+        stripped.gsub(/\s+?(\S+)?$/, "") + "..."
+      else
+        stripped
+      end
+    end
+
+    # Marks task completion
+    # @param [Symbol] state Task completion state
+    # @param [#to_s] result
+    def finish_task(state, result)
+      @task.state = state
+      @task.result = truncate(result.to_s)
+      @task.timestamp = Time.now
+      @task.save
+    end
+
+    # Logs the exception in the event log
+    # @param [Exception] exception
+    def log_exception(exception)
+      # Event log is being used here to propagate the error.
+      # It's up to event log renderer to find the error and
+      # signal it properly.
+      director_error = DirectorError.create_from_exception(exception)
+      Config.event_log.log_error(director_error)
+    end
+
+  end
+end

data/lib/bosh/director/job_updater.rb

@@ -0,0 +1,121 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Director
+
+  class JobUpdater
+
+    # @param [Bosh::Director::DeploymentPlan] deployment_plan
+    # @param [DeploymentPlan::Job] job
+    def initialize(deployment_plan, job)
+      @deployment_plan = deployment_plan
+      @job = job
+      @cloud = Config.cloud
+      @logger = Config.logger
+      @event_log = Config.event_log
+    end
+
+    def delete_unneeded_instances
+      @logger.info("Deleting no longer needed instances")
+      unneeded_instances = @job.unneeded_instances
+
+      return if unneeded_instances.empty?
+
+      @event_log.begin_stage("Deleting unneeded instances",
+                             unneeded_instances.size, [@job.name])
+      InstanceDeleter.new(@deployment_plan).
+        delete_instances(unneeded_instances,
+                         :max_threads => @job.update.max_in_flight)
+
+      @logger.info("Deleted no longer needed instances")
+    end
+
+    def update
+      delete_unneeded_instances
+
+      instances = []
+      @job.instances.each do |instance|
+        instances << instance if instance.changed?
+      end
+
+      if instances.empty?
+        @logger.info("No instances to update for `#{@job.name}'")
+        return
+      end
+
+      @logger.info("Found #{instances.size} instances to update")
+
+      @event_log.begin_stage("Updating job", instances.size, [ @job.name ])
+
+      ThreadPool.new(:max_threads => @job.update.max_in_flight).wrap do |pool|
+        num_canaries = [ @job.update.canaries, instances.size ].min
+
+        @logger.info("Starting canary update")
+        # Canaries first
+        num_canaries.times do
+          instance = instances.shift
+
+          pool.process do
+            desc = "#{@job.name}/#{instance.index}"
+            @event_log.track("#{desc} (canary)") do |ticker|
+              with_thread_name("canary_update(#{desc})") do
+                unless @job.should_halt?
+                  begin
+                    InstanceUpdater.new(instance, ticker).
+                      update(:canary => true)
+                  rescue Exception => e
+                    @logger.error("Error updating canary instance: #{e}\n" +
+                                  "#{e.backtrace.join("\n")}")
+                    @job.record_update_error(e, :canary => true)
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        pool.wait
+        @logger.info("Finished canary update")
+
+        if @job.should_halt?
+          @logger.warn("Halting deployment due to a canary failure")
+          halt
+        end
+
+        # Continue with the rest of the updates
+        @logger.info("Continuing the rest of the update")
+        instances.each do |instance|
+          pool.process do
+            desc = "#{@job.name}/#{instance.index}"
+            @event_log.track(desc) do |ticker|
+              with_thread_name("instance_update(#{desc})") do
+                unless @job.should_halt?
+                  begin
+                    InstanceUpdater.new(instance, ticker).update
+                  rescue Exception => e
+                    @logger.error("Error updating instance: #{e}\n" +
+                                  "#{e.backtrace.join("\n")}")
+                    @job.record_update_error(e)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      @logger.info("Finished the rest of the update")
+
+      if @job.should_halt?
+        @logger.warn("Halting deployment due to an update failure")
+        halt
+      end
+    end
+
+    def halt
+      error = @job.halt_exception ||
+        RuntimeError.new("Deployment has been halted")
+      raise error
+    end
+
+  end
+end

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

@@ -0,0 +1,86 @@
+module Bosh::Director
+  module Jobs
+    class Backup < BaseJob
+      @queue = :normal
+
+      def self.job_type
+        :bosh_backup
+      end
+
+      attr_reader :backup_file
+
+      def initialize(dest, options={})
+        @backup_file = dest
+        @tar_gzipper = options.fetch(:tar_gzipper) { TarGzipper.new }
+        @blobstore_client = options.fetch(:blobstore) { App.instance.blobstores.blobstore }
+        @db_adapter = options.fetch(:db_adapter) { Bosh::Director::DbBackup.create(Config.db_config) }
+        @base_dir = options.fetch(:base_dir) { Config.base_dir }
+        @log_dir = options.fetch(:log_dir) { Config.log_dir }
+      end
+
+      def perform
+        Dir.mktmpdir do |tmp_output_dir|
+          event_log.begin_stage('Backing up director', 4)
+
+          files = []
+
+          if @log_dir
+            backup_logs("#{tmp_output_dir}/logs.tgz")
+            files << 'logs.tgz'
+          end
+
+          backup_task_logs("#{tmp_output_dir}/task_logs.tgz")
+          files << 'task_logs.tgz'
+
+          backup_database("#{tmp_output_dir}/director_db.sql")
+          files << 'director_db.sql'
+
+          backup_blobstore("#{tmp_output_dir}/blobs.tgz")
+          files << 'blobs.tgz'
+
+          @tar_gzipper.compress(tmp_output_dir, files, @backup_file)
+
+          "Backup created at #{@backup_file}"
+        end
+      end
+
+      private
+      def backup_logs(output)
+        track_and_log('Backing up logs') do
+          @tar_gzipper.compress(File.dirname(@log_dir), [File.basename(@log_dir)], output, copy_first: true)
+        end
+      end
+
+      def backup_task_logs(output)
+        track_and_log('Backing up task logs') do
+          @tar_gzipper.compress(@base_dir, %w(tasks), output, copy_first: true)
+        end
+      end
+
+      def backup_database(output)
+        track_and_log('Backing up database') do
+          @db_adapter.export(output)
+        end
+      end
+
+      def backup_blobstore(output)
+        Dir.mktmpdir do |tmp_dir|
+          Dir.mkdir(File.join(tmp_dir, 'blobs'))
+
+          track_and_log('Backing up blobstore') do
+            [Models::Package.all, Models::CompiledPackage.all, Models::Template.all].each do |packages|
+              packages.each do |package|
+                File.open(File.join(tmp_dir, 'blobs', package.blobstore_id), 'w') do |file|
+                  logger.debug("Writing file #{file.path}")
+                  @blobstore_client.get(package.blobstore_id, file)
+                end
+              end
+            end
+
+            @tar_gzipper.compress(tmp_dir, 'blobs', output)
+          end
+        end
+      end
+    end
+  end
+end