bosh_agent 1.5.0.pre.1113

data/lib/bosh_agent/heartbeat_processor.rb

@@ -0,0 +1,45 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Agent
+  class HeartbeatProcessor
+
+    MAX_OUTSTANDING_HEARTBEATS = 2
+
+    def enable(interval)
+      unless EM.reactor_running?
+        raise Bosh::Agent::HeartbeatError, "Event loop must be running in order to enable heartbeats"
+      end
+
+      if @timer
+        Config.logger.warn("Heartbeat timer already running, canceling")
+        disable
+      end
+
+      @pending = 0
+
+      @timer = EM.add_periodic_timer(interval) do
+        beat
+      end
+    end
+
+    def disable
+      Config.logger.info("Disabled heartbeats")
+      @timer.cancel if @timer
+      @timer = nil
+    end
+
+    def beat
+      raise HeartbeatError, "#{@pending} outstanding heartbeat(s)" if @pending > MAX_OUTSTANDING_HEARTBEATS
+
+      Heartbeat.new.send_via_mbus do
+        @pending -= 1
+      end
+      @pending += 1
+    rescue => e
+      Config.logger.warn("Error sending heartbeat: #{e}")
+      Config.logger.warn(e.backtrace.join("\n"))
+      raise e if @pending > MAX_OUTSTANDING_HEARTBEATS
+    end
+
+  end
+end

data/lib/bosh_agent/http_handler.rb

@@ -0,0 +1,135 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+require "thin"
+require "sinatra"
+require "monitor"
+require "common/ssl"
+
+module Bosh::Agent
+
+  class HTTPHandler < Handler
+
+    def self.start
+      new.start
+    end
+
+    def start
+      handler = self
+
+      uri = URI.parse(Config.mbus)
+
+      @server = Thin::Server.new(uri.host, uri.port) do
+        use Rack::CommonLogger
+
+        if uri.userinfo
+          use Rack::Auth::Basic do |user, password|
+            "#{user}:#{password}" == uri.userinfo
+          end
+        end
+
+        map "/" do
+          run AgentController.new(handler)
+        end
+      end
+
+      certificate = Bosh::Ssl::Certificate.new('agent.key',
+                                               'agent.cert',
+                                               uri.host
+      ).load_or_create
+
+      @server.ssl = true
+      @server.ssl_options = {:ssl_verify => false, :ssl_key_file => certificate.key_path, :ssl_cert_file => certificate.certificate_path }
+
+      @server.start!
+    end
+
+    def shutdown
+      @logger.info("Exit")
+      @server.stop
+    end
+
+    def handle_message(json)
+      result = {}
+      result.extend(MonitorMixin)
+
+      cond = result.new_cond
+      timeout_time = Time.now.to_f + 30
+
+      @callback = Proc.new do |response|
+        result.synchronize do
+          result.merge!(response)
+          cond.signal
+        end
+      end
+
+      super(json)
+
+      result.synchronize do
+        while result.empty?
+          timeout = timeout_time - Time.now.to_f
+          unless timeout > 0
+            raise "Timed out"
+          end
+          cond.wait(timeout)
+        end
+      end
+
+      result
+    end
+
+    def publish(reply_to, payload, &blk)
+      response = @callback.call(payload)
+      blk.call if blk
+      response
+    end
+  end
+
+  module Message
+    class ReleaseApplySpec < Base
+
+      def self.process(args)
+        self.new.apply_spec
+      end
+
+      def release_apply_spec
+        #generated from bosh-release and baked into the stemcell
+        "/var/vcap/micro/apply_spec.yml"
+      end
+
+      def apply_spec
+        Psych.load_file(release_apply_spec)
+      end
+    end
+  end
+
+  class AgentController < Sinatra::Base
+
+    def initialize(handler)
+      super()
+      @handler = handler
+    end
+
+    configure do
+      set(:show_exceptions, false)
+      set(:raise_errors, false)
+      set(:dump_errors, false)
+    end
+
+    post "/agent" do
+      body = request.env["rack.input"].read
+      response = handle_message(body)
+      content_type(:json)
+      response
+    end
+
+    def handle_message(json)
+      begin
+        payload = @handler.handle_message(json)
+      rescue => e
+        payload = RemoteException.from(e).to_hash
+      end
+
+      Yajl::Encoder.encode(payload, :terminator => "\n")
+    end
+  end
+end

data/lib/bosh_agent/infrastructure/aws/registry.rb

@@ -0,0 +1,177 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Agent
+  class Infrastructure::Aws::Registry
+    class << self
+
+      API_TIMEOUT           = 86400 * 3
+      CONNECT_TIMEOUT       = 30
+        INSTANCE_DATA_URI = "http://169.254.169.254/latest"
+
+      def get_uri(uri)
+        client = HTTPClient.new
+        client.send_timeout = API_TIMEOUT
+        client.receive_timeout = API_TIMEOUT
+        client.connect_timeout = CONNECT_TIMEOUT
+
+        response = client.get(INSTANCE_DATA_URI + uri)
+        unless response.status == 200
+          raise(LoadSettingsError, "Instance metadata endpoint returned " \
+                                   "HTTP #{response.status}")
+        end
+
+        response.body
+      rescue HTTPClient::BadResponseError => e
+        raise(LoadSettingsError,
+              "Received bad HTTP response for #{uri}: #{e.inspect}")
+      rescue HTTPClient::TimeoutError
+        raise(LoadSettingsError,
+              "Timed out reading uri #{uri}, " \
+              "please make sure agent is running on EC2 instance")
+      rescue URI::Error, SocketError, Errno::ECONNREFUSED, SystemCallError => e
+        raise(LoadSettingsError,
+              "Error requesting current instance id from #{uri} #{e.inspect}")
+      end
+
+      ##
+      # Reads current instance id from EC2 metadata. We are assuming
+      # instance id cannot change while current process is running
+      # and thus memoizing it.
+      def current_instance_id
+        return @current_instance_id if @current_instance_id
+        @current_instance_id = get_uri("/meta-data/instance-id/")
+      end
+
+      def get_json_from_url(url)
+        client = HTTPClient.new
+        client.send_timeout = API_TIMEOUT
+        client.receive_timeout = API_TIMEOUT
+        client.connect_timeout = CONNECT_TIMEOUT
+
+        headers = {"Accept" => "application/json"}
+        response = client.get(url, {}, headers)
+
+        if response.status != 200
+          raise(LoadSettingsError,
+                "Cannot read settings for `#{url}' from registry, " \
+                "got HTTP #{response.status}")
+        end
+
+        body = Yajl::Parser.parse(response.body)
+        unless body.is_a?(Hash)
+          raise(LoadSettingsError,
+                "Invalid response from #{url} , Hash expected, " \
+                "got #{body.class}: #{body}")
+        end
+
+        body
+
+      rescue HTTPClient::BadResponseError => e
+        raise(LoadSettingsError,
+              "Received bad HTTP response from registry: #{e.inspect}")
+      rescue HTTPClient::TimeoutError
+        raise(LoadSettingsError,
+              "Timed out reading json from #{url}, " \
+              "please make sure agent is running on EC2 instance")
+      rescue URI::Error, SocketError, Errno::ECONNREFUSED, SystemCallError => e
+        raise(LoadSettingsError,
+              "Error requesting registry information #{e.inspect}")
+      rescue Yajl::ParseError => e
+        raise(LoadSettingsError,
+              "Cannot parse settings for from registry #{e.inspect}")
+      end
+
+      def get_registry_endpoint
+        user_data = get_json_from_url(INSTANCE_DATA_URI + "/user-data")
+        unless user_data.has_key?("registry") &&
+               user_data["registry"].has_key?("endpoint")
+          raise(LoadSettingsError,
+                "Cannot parse user data for endpoint #{user_data.inspect}")
+        end
+        Bosh::Agent::Config.logger.info("got user_data: #{user_data}")
+        lookup_registry(user_data)
+      end
+
+      # If the registry endpoint is specified with a bosh dns name, e.g.
+      # 0.registry.default.aws.bosh, then the agent needs to lookup the
+      # name and insert the IP address, as the agent doesn't update
+      # resolv.conf until after the bootstrap is run.
+      def lookup_registry(user_data)
+        endpoint = user_data["registry"]["endpoint"]
+
+        # if we get data from an old director which doesn't set dns
+        # info, there is noting we can do, so just return the endpoint
+        if user_data["dns"].nil? || user_data["dns"]["nameserver"].nil?
+          return endpoint
+        end
+
+        hostname = extract_registry_hostname(endpoint)
+
+        # if the registry endpoint is an IP address, just return the endpoint
+        unless (IPAddr.new(hostname) rescue(nil)).nil?
+          return endpoint
+        end
+
+        nameservers = user_data["dns"]["nameserver"]
+        ip = bosh_lookup(hostname, nameservers)
+        inject_registry_ip(ip, endpoint)
+      rescue Resolv::ResolvError => e
+        raise(LoadSettingsError,
+              "Cannot lookup #{hostname} using #{nameservers.join(', ')}" +
+                  "\n#{e.inspect}")
+      end
+
+      def bosh_lookup(hostname, nameservers)
+        resolver = Resolv.new([Resolv::Hosts.new, Resolv::DNS.new(nameserver: nameservers)])
+        resolver.each_address(hostname) do |address|
+          begin
+            return address if IPAddr.new(address).ipv4?
+          rescue ArgumentError
+          end
+        end
+        raise Resolv::ResolvError, "Could not resolve #{hostname}"
+      end
+
+      def extract_registry_hostname(endpoint)
+        uri = URI.parse(endpoint)
+        hostname = uri.hostname
+
+        if hostname.nil?
+          raise LoadSettingsError, "Could not extract registry hostname"
+        end
+
+        hostname
+      end
+
+      def inject_registry_ip(ip, endpoint)
+        uri = URI.parse(endpoint)
+        uri.hostname = ip
+        uri.to_s
+      end
+
+      def get_openssh_key
+        get_uri("/meta-data/public-keys/0/openssh-key")
+      end
+
+      def get_settings
+        @registry_endpoint ||= get_registry_endpoint
+        url = "#{@registry_endpoint}/instances/#{current_instance_id}/settings"
+        body = get_json_from_url(url)
+
+        settings = Yajl::Parser.parse(body["settings"])
+        unless settings.is_a?(Hash)
+          raise(LoadSettingsError, "Invalid settings format, " \
+                      "Hash expected, got #{settings.class}: " \
+                      "#{settings}")
+        end
+
+        settings
+
+      rescue Yajl::ParseError
+        raise(LoadSettingsError,
+              "Cannot parse settings from registry #{@registry_endpoint}")
+      end
+
+    end
+  end
+end

data/lib/bosh_agent/infrastructure/aws/settings.rb

@@ -0,0 +1,59 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Agent
+  class Infrastructure::Aws::Settings
+
+    VIP_NETWORK_TYPE = "vip"
+    DHCP_NETWORK_TYPE = "dynamic"
+    MANUAL_NETWORK_TYPE = "manual"
+
+    SUPPORTED_NETWORK_TYPES = [
+      VIP_NETWORK_TYPE, DHCP_NETWORK_TYPE, MANUAL_NETWORK_TYPE
+    ]
+
+    AUTHORIZED_KEYS = File.join("/home/", BOSH_APP_USER, ".ssh/authorized_keys")
+
+    def logger
+      Bosh::Agent::Config.logger
+    end
+
+    def authorized_keys
+      AUTHORIZED_KEYS
+    end
+
+    def setup_openssh_key
+      public_key = Infrastructure::Aws::Registry.get_openssh_key
+      if public_key.nil? || public_key.empty?
+        return
+      end
+      FileUtils.mkdir_p(File.dirname(authorized_keys))
+      FileUtils.chmod(0700, File.dirname(authorized_keys))
+      FileUtils.chown(Bosh::Agent::BOSH_APP_USER, Bosh::Agent::BOSH_APP_GROUP,
+                      File.dirname(authorized_keys))
+      File.open(authorized_keys, "w") { |f| f.write(public_key) }
+      FileUtils.chown(Bosh::Agent::BOSH_APP_USER, Bosh::Agent::BOSH_APP_GROUP,
+                      authorized_keys)
+      FileUtils.chmod(0644, authorized_keys)
+    end
+
+    def load_settings
+      setup_openssh_key
+      Infrastructure::Aws::Registry.get_settings
+    end
+
+    def get_network_settings(network_name, properties)
+      type = properties["type"] || "manual"
+      unless type && SUPPORTED_NETWORK_TYPES.include?(type)
+        raise Bosh::Agent::StateError,
+              "Unsupported network type '%s', valid types are: %s" %
+                  [type, SUPPORTED_NETWORK_TYPES.join(', ')]
+      end
+
+      # Nothing to do for "vip" and "manual" networks
+      return nil if [VIP_NETWORK_TYPE, MANUAL_NETWORK_TYPE].include? type
+
+      Bosh::Agent::Util.get_network_info
+    end
+
+  end
+end

data/lib/bosh_agent/infrastructure/aws.rb

@@ -0,0 +1,17 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Agent
+  class Infrastructure::Aws
+    require 'bosh_agent/infrastructure/aws/settings'
+    require 'bosh_agent/infrastructure/aws/registry'
+
+    def load_settings
+      Settings.new.load_settings
+    end
+
+    def get_network_settings(network_name, properties)
+      Settings.new.get_network_settings(network_name, properties)
+    end
+
+  end
+end

data/lib/bosh_agent/infrastructure/dummy.rb

@@ -0,0 +1,24 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::Agent
+  class Infrastructure::Dummy
+
+    def load_settings
+      {
+        "blobstore" => {
+          "provider" => Bosh::Agent::Config.blobstore_provider,
+          "options" => Bosh::Agent::Config.blobstore_options,
+        },
+        "ntp" => [],
+        "disks" => {
+          "persistent" => {},
+        },
+        "mbus" => Bosh::Agent::Config.mbus,
+      }
+    end
+
+    def get_network_settings(network_name, properties)
+      # Nothing to do
+    end
+  end
+end

data/lib/bosh_agent/infrastructure/openstack/registry.rb

@@ -0,0 +1,220 @@
+# Copyright (c) 2009-2013 VMware, Inc.
+
+module Bosh::Agent
+  class Infrastructure::Openstack::Registry
+    class << self
+
+      attr_accessor :user_data
+
+      HTTP_API_TIMEOUT     = 300
+      HTTP_CONNECT_TIMEOUT = 30
+      META_DATA_URI = "http://169.254.169.254/latest"
+      USER_DATA_FILE = File.join(File::SEPARATOR, "var", BOSH_APP_USER, "bosh", "user_data.json")
+
+      ##
+      # Returns the logger.
+      #
+      # @return [Logger] Bosh Agent logger
+      def logger
+        Bosh::Agent::Config.logger
+      end
+
+      ##
+      # Gets the OpenSSH public key. First we try to get it from the OpenStack meta data endpoint, if we fail,
+      # then we fallback to the injected user data file.
+      #
+      # @return [String] OpenSSH key
+      def get_openssh_key
+        get_uri(META_DATA_URI + "/meta-data/public-keys/0/openssh-key")
+      rescue LoadSettingsError => e
+        logger.info("Failed to get OpenSSH public key from OpenStack meta data endpoint: #{e.message}")
+        user_data = parse_user_data(get_user_data_from_file)
+        unless user_data.has_key?("openssh") && user_data["openssh"].has_key?("public_key")
+          raise LoadSettingsError, "Cannot get OpenSSH public key from injected user data file: #{user_data.inspect}"
+        end
+        user_data["openssh"]["public_key"]
+      end
+
+      ##
+      # Gets the settings for this agent from the Bosh registry.
+      #
+      # @return [Hash] Agent Settings
+      def get_settings
+        @registry_endpoint ||= get_registry_endpoint
+        url = "#{@registry_endpoint}/instances/#{get_server_name}/settings"
+        raw_response = get_uri(url)
+
+        registry_data = Yajl::Parser.parse(raw_response)
+        unless registry_data.is_a?(Hash) && registry_data.has_key?("settings")
+          raise LoadSettingsError, "Invalid response received from Bosh registry, " \
+                                   "got #{registry_data.class}: #{registry_data}"
+        end
+
+        settings = Yajl::Parser.parse(registry_data["settings"])
+        unless settings.is_a?(Hash)
+          raise(LoadSettingsError, "Invalid settings received from Bosh registry, " \
+                                   "got #{settings.class}: #{settings}")
+        end
+
+        settings
+      rescue Yajl::ParseError => e
+        raise LoadSettingsError, "Cannot parse settings from Bosh registry, got #{raw_response} - #{e.message}"
+      end
+
+      ##
+      # Gets the server name from OpenStack user data.
+      #
+      # @return [String] OpenStack server name
+      def get_server_name
+        user_data = get_user_data
+        unless user_data.has_key?("server") && user_data["server"].has_key?("name")
+          raise LoadSettingsError, "Cannot get OpenStack server name from user data #{user_data.inspect}"
+        end
+        user_data["server"]["name"]
+      end
+
+      ##
+      # Gets the Bosh registry endpoint from OpenStack user data.
+      #
+      # @return [String] Bosh registry endpoint
+      def get_registry_endpoint
+        user_data = get_user_data
+        unless user_data.has_key?("registry") && user_data["registry"].has_key?("endpoint")
+          raise LoadSettingsError, "Cannot get Bosh registry endpoint from user data #{user_data.inspect}"
+        end
+        lookup_registry_endpoint(user_data)
+      end
+
+      ##
+      # If the Bosh registry endpoint is specified with a Bosh DNS name, i.e. 0.registry.default.openstack.bosh,
+      # then the agent needs to lookup the name and insert the IP address, as the agent doesn't update
+      # resolv.conf until after the bootstrap is run.
+      #
+      # @param [Hash] user_data OpenStack user data (generated by the CPI)
+      # @return [String] Bosh registry endpoint
+      def lookup_registry_endpoint(user_data)
+        registry_endpoint = user_data["registry"]["endpoint"]
+
+        # If user data doesn't contain dns info, there is noting we can do, so just return the endpoint
+        return registry_endpoint if user_data["dns"].nil? || user_data["dns"]["nameserver"].nil?
+
+        # If the endpoint is an IP address, just return the endpoint
+        registry_hostname = extract_registry_hostname(registry_endpoint)
+        return registry_endpoint unless (IPAddr.new(registry_hostname) rescue(nil)).nil?
+
+        nameservers = user_data["dns"]["nameserver"]
+        registry_ip = lookup_registry_ip_address(registry_hostname, nameservers)
+        inject_registry_ip_address(registry_ip, registry_endpoint)
+      rescue Resolv::ResolvError => e
+        raise LoadSettingsError, "Cannot lookup #{registry_hostname} using #{nameservers.join(", ")}: #{e.inspect}"
+      end
+
+      ##
+      # Extracts the hostname from the Bosh registry endpoint.
+      #
+      # @param [String] endpoint Bosh registry endpoint
+      # @return [String] Bosh registry hostname
+      def extract_registry_hostname(endpoint)
+        match = endpoint.match(%r{https*://([^:]+):})
+        unless match && match.size == 2
+          raise LoadSettingsError, "Cannot extract Bosh registry hostname from #{endpoint}"
+        end
+        match[1]
+      end
+
+      ##
+      # Lookups for the Bosh registry IP address.
+      #
+      # @param [String] hostname Bosh registry hostname
+      # @param [Array] nameservers Array containing nameserver address
+      # @return [Resolv::IPv4] Bosh registry IP address
+      def lookup_registry_ip_address(hostname, nameservers)
+        resolver = Resolv::DNS.new(:nameserver => nameservers)
+        resolver.getaddress(hostname)
+      end
+
+      ##
+      # Injects an IP address in the Bosh registry endpoint.
+      #
+      # @param [Resolv::IPv4] ip Bosh registry IP address
+      # @param [String] endpoint Bosh registry endpoint
+      # @return [String] Bosh registry endpoint
+      def inject_registry_ip_address(ip, endpoint)
+        endpoint.sub(%r{//[^:]+:}, "//#{ip}:")
+      end
+
+      ##
+      # Gets the OpenStack user data. First we try to get it from the OpenStack user data endpoint, if we fail,
+      # then we fallback to the injected user data file.
+      #
+      # @return [Hash] OpenStack user data
+      def get_user_data
+        return @user_data if @user_data
+        begin
+          raw_user_data = get_uri(META_DATA_URI + "/user-data")
+        rescue LoadSettingsError => e
+          logger.info("Failed to get user data from OpenStack user data endpoint: #{e.message}")
+          raw_user_data = get_user_data_from_file
+        end
+
+        logger.info("OpenStack user data: #{raw_user_data.inspect}")
+        @user_data = parse_user_data(raw_user_data)
+      end
+
+      ##
+      # Gets the OpenStack user data from the injected user data file.
+      #
+      # @return [String] OpenStack user data
+      def get_user_data_from_file
+        File.read(USER_DATA_FILE)
+      rescue SystemCallError => e
+        raise LoadSettingsError, "Failed to get user data from OpenStack injected user data file: #{e.message}"
+      end
+
+      ##
+      # Parses the OpenStack user data.
+      #
+      # @param [String] raw_user_data Raw OpenStack user data
+      # @return [Hash] OpenStack user data
+      def parse_user_data(raw_user_data)
+        begin
+          user_data = Yajl::Parser.parse(raw_user_data)
+        rescue Yajl::ParseError => e
+          raise LoadSettingsError, "Cannot parse user data #{raw_user_data.inspect}: #{e.message}"
+        end
+
+        unless user_data.is_a?(Hash)
+          raise LoadSettingsError, "Invalid user data format, Hash expected, got #{user_data.class}: #{user_data}"
+        end
+
+        user_data
+      end
+
+      ##
+      # Sends GET request to an specified URI.
+      #
+      # @param [String] uri URI to request
+      # @return [String] Response body
+      def get_uri(uri)
+        client = HTTPClient.new
+        client.send_timeout = HTTP_API_TIMEOUT
+        client.receive_timeout = HTTP_API_TIMEOUT
+        client.connect_timeout = HTTP_CONNECT_TIMEOUT
+
+        headers = {"Accept" => "application/json"}
+        response = client.get(uri, {}, headers)
+        unless response.status == 200
+          raise LoadSettingsError, "Endpoint #{uri} returned HTTP #{response.status}"
+        end
+
+        response.body
+      rescue HTTPClient::TimeoutError
+        raise LoadSettingsError, "Timed out reading endpoint #{uri}"
+      rescue HTTPClient::BadResponseError => e
+        raise LoadSettingsError, "Received bad HTTP response from endpoint #{uri}: #{e.inspect}"
+      rescue URI::Error, SocketError, Errno::ECONNREFUSED, SystemCallError => e
+        raise LoadSettingsError, "Error requesting endpoint #{uri}: #{e.inspect}"
+      end
+    end
+  end
+end