bosh_agent 1.5.0.pre.1113

data/lib/bosh_agent/monit_client.rb

@@ -0,0 +1,158 @@
+require "logger"
+require "net/http"
+require "crack"
+
+module Bosh::Agent
+  class MonitClient
+    TYPES = {
+      :file_system => 0,
+      :directory => 1,
+      :file => 2,
+      :process => 3,
+      :remote_host => 4,
+      :system => 5,
+      :fifo => 6
+    }
+
+    TYPES_INVERSE = TYPES.invert
+
+    STATUS_MESSAGES = {
+      :file_system => "accessible",
+      :directory => "accessible",
+      :file => "accessible",
+      :process => "running",
+      :remote_host => "online with all services",
+      :system => "running",
+      :fifo => "accessible"
+    }
+
+    MONITOR = {
+      :no => 0,
+      :yes => 1,
+      :init => 2
+    }
+
+    MONITOR_INVERSE = MONITOR.invert
+
+    def initialize(uri, options = {})
+      @logger = options[:logger] || Logger.new(nil)
+      @uri = URI.parse(uri)
+    end
+
+    def start(arg)
+      service_names(arg).each { |service_name| service_action(service_name, "start") }
+    end
+
+    def stop(arg)
+      service_names(arg).each { |service_name| service_action(service_name, "stop") }
+    end
+
+    def restart(arg)
+      service_names(arg).each { |service_name| service_action(service_name, "restart") }
+    end
+
+    def monitor(arg)
+      service_names(arg).each { |service_name| service_action(service_name, "monitor") }
+    end
+
+    def unmonitor(arg)
+      service_names(arg).each { |service_name| service_action(service_name, "unmonitor") }
+    end
+
+    def status(arg)
+      status = get_status
+      services = get_services(status, arg)
+      result = {}
+      services.each do |service|
+        type = TYPES_INVERSE[service["type"].to_i]
+        status_message = service["status_message"] || STATUS_MESSAGES[type]
+        result[service["name"]] = {
+          :type => type,
+          :status => {
+            :code => service["status"].to_i,
+            :message => status_message
+          },
+          :monitor => MONITOR_INVERSE[service["monitor"].to_i],
+          :raw => service
+        }
+      end
+      result
+    end
+
+    def monit_info
+      status = get_status
+      monit_status = status["monit"]
+      {
+        :id => monit_status["id"],
+        :incarnation => monit_status["incarnation"],
+        :version => monit_status["version"]
+      }
+    end
+
+    private
+
+    def get_status
+      http = Net::HTTP.new(@uri.host, @uri.port)
+      request = Net::HTTP::Get.new("/_status2?format=xml")
+      request.basic_auth(@uri.user, @uri.password) if @uri.user || @uri.password
+      response = http.request(request)
+      if response.code != "200"
+        raise response.message
+      end
+
+      Crack::XML.parse(response.body)
+    end
+
+    def service_names(arg)
+      status = get_status
+      services = get_services(status, arg)
+      services.collect { |service| service["name"] }
+    end
+
+    def get_services(status, arg)
+      services = status["monit"]["services"]["service"]
+      services = [services] unless services.kind_of?(Array)
+
+      service_groups_index = {}
+      if status["monit"]["servicegroups"]
+        groups = status["monit"]["servicegroups"]["servicegroup"]
+        groups = [groups] unless groups.kind_of?(Array)
+        groups.each do |group|
+          service_names = group["service"]
+          service_names = [service_names] unless service_names.kind_of?(Array)
+
+          service_names.each do |service_name|
+            service_groups_index[service_name] ||= Set.new
+            service_groups_index[service_name] << group["name"]
+          end
+        end
+      end
+
+      if arg.kind_of?(Hash)
+        if arg.has_key?(:group)
+          services = services.select { |service| service_groups_index[service["name"]] &&
+            service_groups_index[service["name"]].include?(arg[:group]) }
+        end
+        services = services.select { |service| service["type"] == TYPES[arg[:type]].to_s } if arg.has_key?(:type)
+        services
+      elsif arg.kind_of?(String)
+        services.select { |service| service["name"] == arg }
+      else
+        raise ArgumentError
+      end
+    end
+
+    def service_action(service_name, action)
+      @logger.debug("Requesting '#{action}' for #{service_name}")
+      http = Net::HTTP.new(@uri.host, @uri.port)
+      request = Net::HTTP::Post.new("/#{service_name}")
+      request.basic_auth(@uri.user, @uri.password) if @uri.user || @uri.password
+      request.content_type = ("application/x-www-form-urlencoded")
+      request.body = "action=#{action}"
+      response = http.request(request)
+      if response.code != "200"
+        raise response.message
+      end
+    end
+  end
+end

data/lib/bosh_agent/mounter.rb

@@ -0,0 +1,42 @@
+require 'bosh_agent'
+
+module Bosh::Agent
+  class Mounter
+    def initialize(logger, shell_runner=Bosh::Exec)
+      @logger = logger
+      @shell_runner = shell_runner
+    end
+
+    def mount(partition, mount_point, options_hash={})
+      @logger.info("Mounting: #{partition} #{mount_point}")
+      options = build_command_line_options(options_hash)
+
+      results = shell_runner.sh("mount #{options} #{partition} #{mount_point}", on_error: :return)
+
+      if results.failed?
+        raise Bosh::Agent::MessageHandlerError,
+              "Failed to mount: '#{partition}' '#{mount_point}' Exit status: #{results.exit_status} Output: #{results.output}"
+      end
+    end
+
+    private
+
+    attr_reader :shell_runner
+
+    def build_command_line_options(options_hash)
+      command_options = { read_only: '-o ro' }
+      commands = []
+
+      command_options.each do |key,value|
+        if options_hash[key]
+          commands << value
+          options_hash.delete(key)
+        end
+      end
+
+      raise Bosh::Agent::Error, "Invalid options: #{options_hash.inspect}" unless options_hash.empty?
+
+      commands.join(' ')
+    end
+  end
+end

data/lib/bosh_agent/ntp.rb

@@ -0,0 +1,32 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Agent
+  class NTP
+    BAD_SERVER = "bad ntp server"
+    FILE_MISSING = "file missing"
+    BAD_CONTENTS = "bad file contents"
+
+    def self.offset(ntpdate="#{Config.base_dir}/bosh/log/ntpdate.out")
+      result = {}
+      if File.exist?(ntpdate)
+        lines = []
+        File.open(ntpdate) do |file|
+          lines = file.readlines
+        end
+        case lines.last
+        when /^(.+)\s+ntpdate.+offset\s+(-*\d+\.\d+)/
+          result["timestamp"] = $1
+          result["offset"] = $2
+        when /no server suitable for synchronization found/
+          result["message"] = BAD_SERVER
+        else
+          result["message"] = BAD_CONTENTS
+        end
+      else
+        result["message"] = FILE_MISSING
+      end
+      result
+    end
+
+  end
+end

data/lib/bosh_agent/platform/centos/disk.rb

@@ -0,0 +1,27 @@
+module Bosh::Agent
+  class Platform::Centos::Disk < Platform::Linux::Disk
+    def detect_block_device(disk_id)
+      device_path = "/sys/bus/scsi/devices/#{root_disk_scsi_host_id}:0:#{disk_id}:0/block/*"
+      dirs = Dir.glob(device_path)
+      raise Bosh::Agent::DiskNotFoundError, "Unable to find disk #{device_path}" if dirs.empty?
+
+      File.basename(dirs.first)
+    end
+
+    private
+
+    def rescan_scsi_bus
+      File.open("/sys/class/scsi_host/host#{root_disk_scsi_host_id}/scan", 'w') do |file|
+        file.puts '- - -'
+      end
+    end
+
+    def root_disk_scsi_host_id
+      Dir.glob('/sys/bus/scsi/devices/*:0:0:0/block/*').each do |device|
+        if %r{/(?<host_id>\d):0:0:0/.*/sda} =~ device
+          return host_id
+        end
+      end
+    end
+  end
+end

data/lib/bosh_agent/platform/centos/network.rb

@@ -0,0 +1,39 @@
+module Bosh::Agent
+  class Platform::Centos::Network < Platform::Linux::Network
+    include Bosh::Exec
+
+    def initialize(template_dir)
+      super
+    end
+
+    def write_network_interfaces
+      template = ERB.new(load_erb("centos-ifcfg.erb"), 0, '%<>-')
+      networks.each do |name, network|
+        result = template.result(binding)
+        Bosh::Agent::Util::update_file(result, "/etc/sysconfig/network-scripts/ifcfg-#{name}")
+      end
+      restart_networking_service
+    end
+
+    def restart_networking_service
+      @logger.info("Restarting network")
+      sh "service network restart"
+    end
+
+    def write_dhcp_conf
+      template = ERB.new(load_erb("dhclient_conf.erb"), 0, '%<>-')
+      result = template.result(binding)
+      updated = Bosh::Agent::Util::update_file(result, '/etc/dhclient.conf')
+      if updated
+        @logger.info("Updated dhclient.conf")
+        restart_dhclient
+      end
+    end
+
+    def restart_dhclient
+      @logger.info("Restarting network to restart dhclient")
+      sh "service network restart"
+    end
+
+  end
+end

data/lib/bosh_agent/platform/centos/templates/centos-ifcfg.erb

@@ -0,0 +1,9 @@
+DEVICE=<%= network['interface'] %>
+BOOTPROTO=static
+IPADDR=<%= network['ip']%>
+NETMASK=<%= network['netmask']%>
+BROADCAST=<%= network['broadcast'] %>
+<% if network.fetch('default', []).include?('gateway') -%>
+GATEWAY=<%= network['gateway'] %>
+<% end %>
+ONBOOT=yes

data/lib/bosh_agent/platform/centos/templates/dhclient_conf.erb

@@ -0,0 +1,56 @@
+# Configuration file for /sbin/dhclient, which is included in Debian's
+#	dhcp3-client package.
+#
+# This is a sample configuration file for dhclient. See dhclient.conf's
+#	man page for more information about the syntax of this file
+#	and a more comprehensive list of the parameters understood by
+#	dhclient.
+#
+# Normally, if the DHCP server provides reasonable information and does
+#	not leave anything out (like the domain name, for example), then
+#	few changes must be made to this file, if any.
+#
+
+option rfc3442-classless-static-routes code 121 = array of unsigned integer 8;
+
+send host-name "<hostname>";
+#send dhcp-client-identifier 1:0:a0:24:ab:fb:9c;
+#send dhcp-lease-time 3600;
+#supersede domain-name "fugue.com home.vix.com";
+request subnet-mask, broadcast-address, time-offset, routers,
+	domain-name, domain-name-servers, domain-search, host-name,
+	netbios-name-servers, netbios-scope, interface-mtu,
+	rfc3442-classless-static-routes, ntp-servers;
+<% dns.reverse.each do |server| -%>
+prepend domain-name-servers <%= server %>;
+<% end -%>
+
+#require subnet-mask, domain-name-servers;
+#timeout 60;
+#retry 60;
+#reboot 10;
+#select-timeout 5;
+#initial-interval 2;
+#script "/etc/dhcp3/dhclient-script";
+#media "-link0 -link1 -link2", "link0 link1";
+#reject 192.33.137.209;
+
+#alias {
+#  interface "eth0";
+#  fixed-address 192.5.5.213;
+#  option subnet-mask 255.255.255.255;
+#}
+
+#lease {
+#  interface "eth0";
+#  fixed-address 192.33.137.200;
+#  medium "link0 link1";
+#  option host-name "andare.swiftmedia.com";
+#  option subnet-mask 255.255.255.0;
+#  option broadcast-address 192.33.137.255;
+#  option routers 192.33.137.250;
+#  option domain-name-servers 127.0.0.1;
+#  renew 2 2000/1/12 00:00:01;
+#  rebind 2 2000/1/12 00:00:01;
+#  expire 2 2000/1/12 00:00:01;
+#}

data/lib/bosh_agent/platform/centos/templates/logrotate.erb

@@ -0,0 +1,8 @@
+<%= base_dir %>/data/sys/log/*.log <%= base_dir %>/data/sys/log/*/*.log <%= base_dir %>/data/sys/log/*/*/*.log {
+  missingok
+  rotate 7
+  compress
+  delaycompress
+  copytruncate
+  size=<%= size %>
+}

data/lib/bosh_agent/platform/centos.rb

@@ -0,0 +1,4 @@
+module Bosh::Agent
+  module  Platform::Centos
+  end
+end

data/lib/bosh_agent/platform/dummy/templates/dummy_template.erb

@@ -0,0 +1 @@
+This is a dummy variable with <%= dummy %> value

data/lib/bosh_agent/platform/linux/adapter.rb

@@ -0,0 +1,36 @@
+module Bosh::Agent
+  module Platform::Linux
+    class Adapter
+      def initialize(disk, logrotate, password, network)
+        @disk = disk
+        @logrotate = logrotate
+        @password = password
+        @network = network
+      end
+
+      def mount_persistent_disk(cid)
+        @disk.mount_persistent_disk(cid)
+      end
+
+      def update_logging(spec)
+        @logrotate.install(spec)
+      end
+
+      def update_passwords(settings)
+        @password.update(settings)
+      end
+
+      def lookup_disk_by_cid(cid)
+        @disk.lookup_disk_by_cid(cid)
+      end
+
+      def get_data_disk_device_name
+        @disk.get_data_disk_device_name
+      end
+
+      def setup_networking
+        @network.setup_networking
+      end
+    end
+  end
+end

data/lib/bosh_agent/platform/linux/disk.rb

@@ -0,0 +1,121 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Agent
+  class Platform::Linux::Disk
+    include Bosh::Exec
+
+    VSPHERE_DATA_DISK = "/dev/sdb"
+    DEV_PATH_TIMEOUT=180
+    DISK_RETRY_MAX_DEFAULT = 30
+
+    def initialize
+      @config   = Bosh::Agent::Config
+      @platform_name = @config.platform_name
+      @logger   = @config.logger
+      @store_dir = File.join(@config.base_dir, 'store')
+      @dev_path_timeout = DEV_PATH_TIMEOUT
+      @disk_retry_timeout = DISK_RETRY_MAX_DEFAULT
+      @mounter = Mounter.new(@logger)
+    end
+
+    def mount_persistent_disk(cid, options={})
+      FileUtils.mkdir_p(@store_dir)
+      disk = lookup_disk_by_cid(cid)
+      partition = "#{disk}1"
+      if File.blockdev?(partition) && !mount_exists?(partition)
+        mounter.mount(partition, @store_dir, options)
+      end
+    end
+
+    def get_data_disk_device_name
+      case @config.infrastructure_name
+        when "vsphere"
+          VSPHERE_DATA_DISK
+        when "aws", "openstack"
+          settings = @config.settings
+          dev_path = settings['disks']['ephemeral']
+          unless dev_path
+            raise Bosh::Agent::FatalError, "Unknown data or ephemeral disk" if @config.infrastructure_name == "aws"
+            @logger.warn("No ephemeral disk set, using root device for BOSH agent data!!!")
+            return nil
+          end
+          get_available_path(dev_path)
+        else
+          raise Bosh::Agent::FatalError, "Lookup disk failed, unsupported infrastructure #{Bosh::Agent::Config.infrastructure_name}"
+      end
+    end
+
+    def lookup_disk_by_cid(cid)
+      disk_id = @config.settings['disks']['persistent'][cid]
+
+      if disk_id.nil?
+        raise Bosh::Agent::FatalError, "Unknown persistent disk: #{cid}"
+      end
+
+      case @config.infrastructure_name
+        when "vsphere"
+          # VSphere passes in scsi disk id
+          get_available_scsi_path(disk_id)
+        when "aws", "openstack"
+          # AWS & OpenStack pass in the device name
+          get_available_path(disk_id)
+        else
+          raise Bosh::Agent::FatalError, "Lookup disk failed, unsupported infrastructure #{Bosh::Agent::Config.infrastructure_name}"
+      end
+    end
+
+    def detect_block_device(disk_id)
+      device_path = "/sys/bus/scsi/devices/2:0:#{disk_id}:0/block/*"
+      dirs = Dir.glob(device_path, 0)
+      raise Bosh::Agent::DiskNotFoundError, "Unable to find disk #{device_path}" if dirs.empty?
+
+      File.basename(dirs.first)
+    end
+
+    private
+
+    def rescan_scsi_bus
+      sh "rescan-scsi-bus.sh"
+    end
+
+    def get_dev_paths(dev_path)
+      dev_paths = [] << dev_path
+      dev_path_suffix = dev_path.match("/dev/sd(.*)")
+      unless dev_path_suffix.nil?
+        dev_paths << "/dev/vd#{dev_path_suffix[1]}"  # KVM
+        dev_paths << "/dev/xvd#{dev_path_suffix[1]}" # Xen
+      end
+      dev_paths
+    end
+
+    def get_available_path(dev_path)
+      start = Time.now
+      dev_paths = get_dev_paths(dev_path)
+      while Dir.glob(dev_paths).empty?
+        @logger.info("Waiting for #{dev_paths}")
+        sleep 0.1
+        if (Time.now - start) > @dev_path_timeout
+          raise Bosh::Agent::FatalError, "Timed out waiting for #{dev_paths}"
+        end
+      end
+      Dir.glob(dev_paths).last
+    end
+
+    def get_available_scsi_path(disk_id)
+      rescan_scsi_bus
+      blockdev = nil
+      Bosh::Common.retryable(tries: @disk_retry_timeout, on: Bosh::Agent::DiskNotFoundError) do
+        blockdev = detect_block_device(disk_id)
+      end
+      File.join('/dev', blockdev)
+    end
+
+    def mount_exists?(partition)
+      File.read('/proc/mounts').lines.select { |l| l.match(/#{partition}/) }.first
+    end
+
+    private
+
+    attr_reader :mounter
+  end
+end

data/lib/bosh_agent/platform/linux/logrotate.rb

@@ -0,0 +1,32 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Agent
+  class Platform::Linux::Logrotate
+    DEFAULT_MAX_LOG_FILE_SIZE = "50M"
+
+    def initialize(template_dir)
+      @logger = Bosh::Agent::Config.logger
+      @template_src = File.join template_dir, "logrotate.erb"
+      @template_dst = File.join Bosh::Agent::Config.system_root, "etc", "logrotate.d", BOSH_APP_GROUP
+    end
+
+    def install(spec={})
+      # These local variables are used in the template context
+      # (see Bosh::Agent::Template class implementation)
+      base_dir = Bosh::Agent::Config.base_dir
+      size = max_log_file_size(spec['properties'])
+      @logger.debug "Compiling template #@template_src to #@template_dst"
+      Template.write do |t|
+        t.src @template_src
+        t.dst @template_dst
+      end
+    end
+
+    private
+    def max_log_file_size(properties)
+      (properties || {}).
+          fetch('logging', {}).
+          fetch('max_log_file_size', DEFAULT_MAX_LOG_FILE_SIZE)
+    end
+  end
+end