bosh_agent 1.5.0.pre.1113

data/lib/bosh_agent/message/compile_package.rb

@@ -0,0 +1,250 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require 'blobstore_client'
+
+module Bosh::Agent
+  module Message
+    # This agent message "compile_package" fetches the source package from
+    # the blobstore, fetches the dependency compiled packages, compiles the
+    # source package, packs it into a tgz blob, and uploads it to the same
+    # blobstore. It returns the uploaded blob's blobstore_id & sha1.
+    #
+    # This message has the following uses:
+    # * the bosh-release (within the stemcell_builder) to
+    #   compile packages to the microbosh's local blobstore
+    # * the director requests packages be compiled during deployment
+    #   if they are not yet compiled and available in the blobstore
+    #
+    # Source packages must have a `packaging` executable script. It can find the
+    # unpackaged source files in the directory it is run in (which is also provided
+    # as $BOSH_COMPILE_TARGET variable).
+    # The packaging script MUST place all compiled assets within the single folder
+    # specified as $BOSH_INSTALL_TARGET.
+    # The packaging script is also provided the environment variables $BOSH_PACKAGE_NAME
+    # and $BOSH_PACKAGE_VERSION
+    class CompilePackage
+      attr_accessor :blobstore_id, :package_name, :package_version, :package_sha1
+      attr_accessor :compile_base, :install_base
+      attr_reader :blobstore_client
+
+      def self.process(args)
+        self.new(args).start
+      end
+      def self.long_running?; true; end
+
+      def initialize(args)
+        bsc_provider = Bosh::Agent::Config.blobstore_provider
+        bsc_options = Bosh::Agent::Config.blobstore_options
+        @blobstore_client = Bosh::Blobstore::Client.create(bsc_provider, bsc_options)
+        @blobstore_id, @sha1, @package_name, @package_version, @dependencies = args
+
+        @base_dir = Bosh::Agent::Config.base_dir
+
+        # The maximum amount of disk percentage that can be used during
+        # compilation before an error will be thrown.  This is to prevent
+        # package compilation throwing arbitrary errors when disk space runs
+        # out.
+        # @attr [Integer] The max percentage of disk that can be used in
+        #     compilation.
+        @max_disk_usage_pct = 90
+        FileUtils.mkdir_p(File.join(@base_dir, 'data', 'tmp'))
+
+        @log_file = "#{@base_dir}/data/tmp/#{Bosh::Agent::Config.agent_id}"
+        @logger = Logger.new(@log_file)
+        @logger.level = Logger::DEBUG
+        @compile_base = "#{@base_dir}/data/compile"
+        @install_base = "#{@base_dir}/data/packages"
+      end
+
+      def start
+        begin
+          install_dependencies
+          get_source_package
+          unpack_source_package
+          compile
+          pack
+          result = upload
+          clear_log_file(@log_file)
+          return { "result" => result }
+        rescue RuntimeError => e
+          @logger.warn("%s\n%s" % [e.message, e.backtrace.join("\n")])
+          raise Bosh::Agent::MessageHandlerError, e
+        ensure
+          delete_tmp_files
+        end
+      end
+
+
+      # Delete the leftover compilation files after a compilation is done. This
+      # is done so that the reuse_compilation_vms option does not fill up a VM.
+      def delete_tmp_files
+        [@compile_base, @install_base].each do |dir|
+          if Dir.exists?(dir)
+            FileUtils.rm_rf(dir)
+          end
+        end
+      end
+
+      def install_dependencies
+        @logger.info("Installing Dependencies")
+        @dependencies.each do |pkg_name, pkg|
+          @logger.info("Installing depdendency: #{pkg_name} #{pkg.inspect}")
+
+          blobstore_id = pkg['blobstore_id']
+          sha1 = pkg['sha1']
+          install_dir = File.join(@install_base, pkg_name, pkg['version'])
+
+          Util.unpack_blob(blobstore_id, sha1, install_dir)
+
+          pkg_link_dst = File.join(@base_dir, 'packages', pkg_name)
+          FileUtils.ln_sf(install_dir, pkg_link_dst)
+        end
+      end
+
+      def get_source_package
+        compile_tmp = File.join(@compile_base, 'tmp')
+        FileUtils.mkdir_p compile_tmp
+        @source_file = File.join(compile_tmp, @blobstore_id)
+        FileUtils.rm @source_file if File.exist?(@source_file)
+
+        File.open(@source_file, 'w') do |f|
+          @blobstore_client.get(@blobstore_id, f)
+        end
+      end
+
+      def compile_dir
+        @compile_dir ||= File.join(@compile_base, @package_name)
+      end
+
+      def install_dir
+        @install_dir ||= File.join(@install_base, @package_name, @package_version.to_s)
+      end
+
+      def unpack_source_package
+        FileUtils.rm_rf compile_dir if File.directory?(compile_dir)
+
+        FileUtils.mkdir_p compile_dir
+        Dir.chdir(compile_dir) do
+          output = `tar -zxf #{@source_file} 2>&1`
+          @logger.info(output)
+          # stick the output in the blobstore
+          unless $?.exitstatus == 0
+            STDOUT.puts(output)
+            raise Bosh::Agent::MessageHandlerError.new(
+              "Compile Package Unpack Source Failure (exit code: #{$?.exitstatus})",
+              output)
+          end
+        end
+      end
+
+      def disk_info_as_array(path)
+        # "Filesystem   1024-blocks     Used Available Capacity  Mounted on\n
+        # /dev/disk0s2   195312496 92743676 102312820    48%    /\n"
+        df_out = `df -Pk #{path} 2>&1`
+        unless $?.exitstatus == 0
+          raise Bosh::Agent::MessageHandlerError, "Command 'df -Pk #{path}' " +
+              "on compilation VM failed with:\n#{df_out}\nexit code: " +
+              "#{$?.exitstatus}"
+        end
+
+        # "/dev/disk0s2   195312496 92743568 102312928    48%    /\n"
+        df_out = df_out.sub(/[^\/]*/, "")
+        # ["/dev/disk0s2", "195312496", "92743568", "102312928", "48%", "/\n"]
+        df_out.split(/[ ]+/)
+      end
+
+      # Get the amount of total disk (in KBytes).
+      # @param [String] path Path that the disk size is being requested for.
+      # @return [Integer] The total disk size (in KBytes).
+      def disk_total(path)
+        disk_info_as_array(path)[1].to_i
+      end
+
+      # Get the amount of disk being used (in KBytes).
+      # @param [String] path Path that the disk usage is being requested for.
+      # @return [Integer] The amount being used (in KBytes).
+      def disk_used(path)
+        disk_info_as_array(path)[2].to_i
+      end
+
+      # Get the percentage of disk that is used on the compilation VM.
+      # @param [String] path Path that the disk usage is being requested for.
+      # @return [Float] The percentage of disk in use.
+      def pct_disk_used(path)
+        100 * disk_used(path).to_f / disk_total(path).to_f
+      end
+
+      def compile
+        FileUtils.rm_rf install_dir if File.directory?(install_dir)
+        FileUtils.mkdir_p install_dir
+
+        pkg_link_dst = File.join(@base_dir, 'packages', @package_name)
+        FileUtils.ln_sf(install_dir, pkg_link_dst)
+
+        pct_space_used = pct_disk_used(@compile_base)
+        if pct_space_used >= @max_disk_usage_pct
+          raise Bosh::Agent::MessageHandlerError,
+              "Compile Package Failure. Greater than #{@max_disk_usage_pct}% " +
+              "is used (#{pct_space_used}%."
+        end
+        Dir.chdir(compile_dir) do
+
+          # Prevent these from getting inhereted from the agent
+          %w{GEM_HOME BUNDLE_GEMFILE RUBYOPT}.each { |key| ENV.delete(key) }
+
+          ENV['BOSH_COMPILE_TARGET'] = compile_dir
+          ENV['BOSH_INSTALL_TARGET'] = pkg_link_dst
+          ENV['BOSH_PACKAGE_NAME'] = @package_name.to_s
+          ENV['BOSH_PACKAGE_VERSION'] = @package_version.to_s
+          if File.exist?('packaging')
+            @logger.info("Compiling #{@package_name} #{@package_version}")
+            output = `bash -x packaging 2>&1`
+            # stick the output in the blobstore
+            @logger.fatal(output)
+            unless $?.exitstatus == 0
+              raise Bosh::Agent::MessageHandlerError.new(
+                "Compile Package Failure (exit code: #{$?.exitstatus})", output)
+            end
+          end
+        end
+      end
+
+      def compiled_package
+        File.join(@source_file + ".compiled")
+      end
+
+      def pack
+        @logger.info("Packing #{@package_name} #{@package_version}")
+        Dir.chdir(install_dir) do
+          `tar -zcf #{compiled_package} .`
+        end
+      end
+
+      # Clears the log file after a compilation runs.  This is needed because if
+      # reuse_compilation_vms is being used then without clearing the log then
+      # the log from each subsequent compilation will include the previous
+      # compilation's output.
+      # @param [String] log_file Path to the log file.
+      def clear_log_file(log_file)
+        File.delete(log_file) if File.exists?(log_file)
+        @logger = Logger.new(log_file)
+      end
+
+      def upload
+        compiled_blobstore_id = nil
+        File.open(compiled_package, 'r') do |f|
+          compiled_blobstore_id = @blobstore_client.create(f)
+        end
+        compiled_sha1 = Digest::SHA1.file(compiled_package).hexdigest
+        compile_log_id = @blobstore_client.create(@log_file)
+        @logger.info("Uploaded #{@package_name} #{@package_version} " +
+                     "(sha1: #{compiled_sha1}, " +
+                     "blobstore_id: #{compiled_blobstore_id})")
+        @logger = nil
+        { "sha1" => compiled_sha1, "blobstore_id" => compiled_blobstore_id,
+          "compile_log_id" => compile_log_id }
+      end
+
+    end
+  end
+end

data/lib/bosh_agent/message/drain.rb

@@ -0,0 +1,195 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require 'yaml'
+require 'monitor'
+
+module Bosh::Agent
+  module Message
+    class Drain
+
+      HM_NOTIFY_TIMEOUT = 5
+
+      def self.process(args)
+        self.new(args).drain
+      end
+
+      def self.long_running?
+        true
+      end
+
+      def initialize(args)
+        @logger     = Bosh::Agent::Config.logger
+        @nats       = Bosh::Agent::Config.nats
+        @agent_id   = Bosh::Agent::Config.agent_id
+        @old_spec   = Bosh::Agent::Config.state.to_hash
+        @args       = args
+
+        @drain_type = args[0]
+        @spec       = args[1]
+        @drain_script = DrainScript.new
+      end
+
+      def job_change
+        if !@old_spec.key?('job')
+          "job_new"
+        elsif @old_spec['job']['sha1'] == @spec['job']['sha1']
+          "job_unchanged"
+        else
+          "job_changed"
+        end
+      end
+
+      def hash_change
+        if !@old_spec.key?('configuration_hash')
+          "hash_new"
+        elsif @old_spec['configuration_hash'] == @spec['configuration_hash']
+          "hash_unchanged"
+        else
+          "hash_changed"
+        end
+      end
+
+      def drain
+        @logger.info("Draining: #{@args.inspect}")
+
+        if Bosh::Agent::Config.configure
+          Bosh::Agent::Monit.unmonitor_services
+        end
+
+        case @drain_type
+        when "shutdown"
+          drain_for_shutdown
+        when "update"
+          drain_for_update
+        when "status"
+          drain_check_status
+        else
+          raise Bosh::Agent::MessageHandlerError, "Unknown drain type #{@drain_type}"
+        end
+      end
+
+      def drain_for_update
+        if @spec.nil?
+          raise Bosh::Agent::MessageHandlerError, "Drain update called without apply spec"
+        end
+
+        if @old_spec.key?('job') && drain_script_exists?
+          # HACK: We go through the motions below to be able to support drain scripts written as shell scripts
+          run_drain_script(job_change, hash_change, updated_packages.flatten)
+        else
+          0
+        end
+      end
+
+      def drain_for_shutdown
+        lock = Monitor.new
+        delivery_cond = lock.new_cond
+        delivered = false
+
+        if @nats
+          # HM notification should be in sync with VM shutdown
+          Thread.new do
+            @nats.publish("hm.agent.shutdown.#{@agent_id}") do
+              lock.synchronize do
+                delivered = true
+                delivery_cond.signal
+              end
+            end
+          end
+        end
+
+        lock.synchronize do
+          delivery_cond.wait(HM_NOTIFY_TIMEOUT) unless delivered
+        end
+
+        if @old_spec.key?('job') && drain_script_exists?
+          run_drain_script("job_shutdown", "hash_unchanged", [])
+        else
+          0
+        end
+      end
+
+      def drain_check_status
+        run_drain_script("job_check_status", "hash_unchanged", [])
+      end
+
+      def run_drain_script(job_updated, hash_updated, updated_packages)
+        @drain_script.run(job_updated, hash_updated, updated_packages)
+      end
+
+      def updated_packages
+        updated_packages = []
+
+        return updated_packages unless @old_spec.key?('packages')
+
+        # Check old packages
+        updated_packages << @old_spec['packages'].find_all do |pkg_name, pkg|
+          if @spec['packages'].key?(pkg_name)
+            pkg['sha1'] != @spec['packages'][pkg_name]['sha1']
+          else
+            false
+          end
+        end.collect { |package_name, pkg| package_name }
+
+        # New packages counts as new
+        updated_packages << @spec['packages'].find_all do |pkg_name, pkg|
+          unless @old_spec['packages'].key?(pkg_name)
+            true
+          else
+            false
+          end
+        end.collect { |package_name, pkg| package_name }
+      end
+
+      def drain_script_exists?
+        @drain_script.exists?
+      end
+
+    end
+
+    class DrainScript
+      attr_reader :base_dir, :job_template
+
+      def initialize(base_dir=Bosh::Agent::Config.base_dir, job_template=nil)
+        @base_dir = base_dir
+        @job_template = job_template || Bosh::Agent::Config.state.to_hash.fetch('job', {}).fetch('template', 'job')
+      end
+
+      def exists?
+        File.exists?(script_file)
+      end
+
+      def run(job_updated, hash_updated, updated_packages)
+        env = {
+            'PATH' => '/usr/sbin:/usr/bin:/sbin:/bin',
+            'BOSH_CURRENT_STATE' => Yajl::Encoder.encode(@old_spec),
+            'BOSH_APPLY_SPEC' => Yajl::Encoder.encode(@spec)
+        }
+
+        # Drain contract: on success the drain script should return a number exit(0)
+        stdout_rd, stdout_wr = IO.pipe
+
+        args = [  env, script_file, job_updated, hash_updated, *updated_packages ]
+        args += [ :out => stdout_wr, :unsetenv_others => true ]
+        Process.spawn(*args)
+        Process.wait
+        stdout_wr.close
+
+        exit_status = $?.exitstatus
+        output = stdout_rd.read
+
+        unless output.match(/\A-{0,1}\d+\Z/) && exit_status == 0
+          raise Bosh::Agent::MessageHandlerError,
+                "Drain script exit #{exit_status}: #{output}"
+        end
+
+        output.to_i
+      end
+
+      private
+      def script_file
+        "#{base_dir}/jobs/#{job_template}/bin/drain"
+      end
+    end
+  end
+end

data/lib/bosh_agent/message/list_disk.rb

@@ -0,0 +1,25 @@
+require 'bosh_agent/disk_util'
+
+module Bosh::Agent
+  module Message
+    class ListDisk < Base
+      def self.process(args = nil)
+        disk_info = []
+        settings = Bosh::Agent::Config.settings
+
+        if settings["disks"].kind_of?(Hash) && settings["disks"]["persistent"].kind_of?(Hash)
+          cids = settings["disks"]["persistent"]
+        else
+          cids = {}
+        end
+
+        cids.each_key do |cid|
+          disk = Bosh::Agent::Config.platform.lookup_disk_by_cid(cid)
+          partition = "#{disk}1"
+          disk_info << cid unless DiskUtil.mount_entry(partition).nil?
+        end
+        disk_info
+      end
+    end
+  end
+end

data/lib/bosh_agent/message/logs.rb

@@ -0,0 +1,108 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Agent
+  module Message
+    class FetchLogs < Base
+
+      def self.long_running?
+        true
+      end
+
+      def self.process(args)
+        new(args).process
+      end
+
+      attr_accessor :matcher, :aggregator
+
+      def initialize(args)
+        @log_type = args[0]
+        @filters = Set.new(args[1])
+        @state = Bosh::Agent::Config.state.to_hash
+        @matcher = default_matcher
+        @aggregator = Bosh::Agent::FileAggregator.new
+      end
+
+      def process
+        handler_error("matcher for #{@log_type} logs not found") unless @matcher
+        handler_error("aggregator for #{@log_type} logs not found") unless @aggregator
+
+        if @filters && @filters.size > 0
+          @matcher.globs = filter_globs
+        end
+
+        aggregator.matcher = @matcher
+
+        tarball_path = aggregator.generate_tarball
+        tarball_size = File.size(tarball_path)
+
+        logger.info("Generated log tarball: #{tarball_path} (size: #{tarball_size})")
+        blobstore_id = upload_tarball(tarball_path)
+
+        { "blobstore_id" => blobstore_id }
+
+      rescue Bosh::Agent::FileAggregator::DirectoryNotFound => e
+        handler_error("unable to find #{@log_type} logs directory")
+      rescue Bosh::Agent::FileAggregator::Error => e
+        handler_error("error aggregating logs: #{e}")
+      ensure
+        aggregator.cleanup
+      end
+
+      private
+
+      def default_matcher
+        case @log_type.to_s
+        when "job"
+          Bosh::Agent::JobLogMatcher.new(base_dir)
+        when "agent"
+          Bosh::Agent::AgentLogMatcher.new(base_dir)
+        else
+          nil
+        end
+      end
+
+      def filter_globs
+        custom_job_logs = {}
+
+        if @state["job"] && @state["job"]["logs"]
+          logs_spec = @state["job"]["logs"]
+
+          if logs_spec.is_a?(Hash)
+            custom_job_logs = logs_spec
+          else
+            logger.warn("Invalid format for job logs spec: Hash expected, #{logs_spec.class} given")
+            logger.warn("All custom filtering except '--all' thus disabled")
+          end
+        end
+
+        predefined = { "all" => "**/*" }
+
+        predefined.merge(custom_job_logs).inject([]) do |result, (filter_name, glob)|
+          result << glob if @filters.include?(filter_name)
+          result
+        end
+      end
+
+      # @return blobstore id of the uploaded tarball
+      def upload_tarball(path)
+        bsc_options  = Bosh::Agent::Config.blobstore_options
+        bsc_provider = Bosh::Agent::Config.blobstore_provider
+
+        blobstore = Bosh::Blobstore::Client.create(bsc_provider, bsc_options)
+
+        logger.info("Uploading tarball to blobstore")
+
+        blobstore_id = nil
+
+        File.open(path) do |f|
+          blobstore_id = blobstore.create(f)
+        end
+
+        blobstore_id
+      rescue Bosh::Blobstore::BlobstoreError => e
+        handler_error("unable to upload logs to blobstore: #{e}")
+      end
+
+    end
+  end
+end

data/lib/bosh_agent/message/migrate_disk.rb

@@ -0,0 +1,55 @@
+require 'bosh_agent/disk_util'
+
+module Bosh::Agent
+  module Message
+
+    # Migrates persistent data from the old persistent disk to the new
+    # persistent disk.
+    #
+    # This message assumes that two mount messages have been received
+    # and processed: one to mount the old disk at /var/vcap/store and
+    # a second to mount the new disk at /var/vcap/store_migraton_target
+    # (sic).
+    class MigrateDisk < Base
+      def self.long_running?; true; end
+
+      def self.process(args)
+        #logger = Bosh::Agent::Config.logger
+        #logger.info("MigrateDisk:" + args.inspect)
+
+        self.new.migrate(args)
+        {}
+      end
+
+      def migrate(args)
+        logger.info("MigrateDisk:" + args.inspect)
+        @old_cid, @new_cid = args
+
+        DiskUtil.umount_guard(store_path)
+
+        mount_store(@old_cid, read_only: true)
+
+        if check_mountpoints
+          logger.info("Copy data from old to new store disk")
+          `(cd #{store_path} && tar cf - .) | (cd #{store_migration_target} && tar xpf -)`
+        end
+
+        DiskUtil.umount_guard(store_path)
+        DiskUtil.umount_guard(store_migration_target)
+
+        mount_store(@new_cid)
+      end
+
+      private
+      def check_mountpoints
+        Pathname.new(store_path).mountpoint? && Pathname.new(store_migration_target).mountpoint?
+      end
+
+      def mount_store(cid, options={})
+        device = Config.platform.lookup_disk_by_cid(cid)
+        partition = "#{device}1"
+        Mounter.new(logger).mount(partition, store_path, options)
+      end
+    end
+  end
+end