bosh_aws_cpi 0.3.3

data/lib/cloud/aws/dynamic_network.rb

@@ -0,0 +1,28 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::AwsCloud
+  ##
+  #
+  class DynamicNetwork < Network
+
+    ##
+    # Creates a new dynamic network
+    #
+    # @param [String] name Network name
+    # @param [Hash] spec Raw network spec
+    def initialize(name, spec)
+      super
+    end
+
+    ##
+    # Configures EC2 dynamic network. Right now it's a no-op,
+    # as dynamic networks are completely managed by EC2
+    # @param [AWS:EC2] instance EC2 client
+    # @param [AWS::EC2::Instance] EC2 instance to configure
+    def configure(ec2, instance)
+    end
+
+  end
+end
+
+

data/lib/cloud/aws/helpers.rb

@@ -0,0 +1,58 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::AwsCloud
+
+  module Helpers
+
+    DEFAULT_TIMEOUT = 3600
+
+    ##
+    # Raises CloudError exception
+    #
+    def cloud_error(message)
+      if @logger
+        @logger.error(message)
+      end
+      raise Bosh::Clouds::CloudError, message
+    end
+
+    def wait_resource(resource, start_state,
+                      target_state, state_method = :status,
+                      timeout = DEFAULT_TIMEOUT)
+
+      started_at = Time.now
+      state = resource.send(state_method)
+      desc = resource.to_s
+
+      while state == start_state && state != target_state
+        duration = Time.now - started_at
+
+        if duration > timeout
+          cloud_error("Timed out waiting for #{desc} " \
+                      "to be #{target_state}")
+        end
+
+        if @logger
+          @logger.debug("Waiting for #{desc} " \
+                        "to be #{target_state} (#{duration})")
+        end
+
+        sleep(1)
+
+        state = resource.send(state_method)
+      end
+
+      if state == target_state
+        if @logger
+          @logger.info("#{desc} is #{target_state} " \
+                       "after #{Time.now - started_at}s")
+        end
+      else
+        cloud_error("#{desc} is #{state}, " \
+                    "expected to be #{target_state}")
+      end
+    end
+  end
+
+end
+

data/lib/cloud/aws/network.rb

@@ -0,0 +1,37 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::AwsCloud
+  ##
+  #
+  class Network
+    include Helpers
+
+    ##
+    # Creates a new network
+    #
+    # @param [String] name Network name
+    # @param [Hash] spec Raw network spec
+    def initialize(name, spec)
+      unless spec.is_a?(Hash)
+        raise ArgumentError, "Invalid spec, Hash expected, " \
+                             "#{spec.class} provided"
+      end
+
+      @logger = Bosh::Clouds::Config.logger
+
+      @name = name
+      @ip = spec["ip"]
+      @cloud_properties = spec["cloud_properties"]
+    end
+
+    ##
+    # Configures given instance
+    #
+    # @param [AWS:EC2] instance EC2 client
+    # @param [AWS::EC2::Instance] EC2 instance to configure
+    def configure(ec2, instance)
+      cloud_error("`configure' not implemented by #{self.class}")
+    end
+
+  end
+end

data/lib/cloud/aws/network_configurator.rb

@@ -0,0 +1,112 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::AwsCloud
+  ##
+  # Represents AWS instance network config. EC2 instance has single NIC
+  # with dynamic IP address and (optionally) a single elastic IP address
+  # which instance itself is not aware of (vip). Thus we should perform
+  # a number of sanity checks for the network spec provided by director
+  # to make sure we don't apply something EC2 doesn't understand how to
+  # deal with.
+  #
+  class NetworkConfigurator
+    include Helpers
+
+    ##
+    # Creates new network spec
+    #
+    # @param [Hash] spec raw network spec passed by director
+    # TODO Add network configuration examples
+    def initialize(spec)
+      unless spec.is_a?(Hash)
+        raise ArgumentError, "Invalid spec, Hash expected, " \
+                             "#{spec.class} provided"
+      end
+
+      @logger = Bosh::Clouds::Config.logger
+      @dynamic_network = nil
+      @vip_network = nil
+      @security_groups = []
+
+      spec.each_pair do |name, spec|
+        network_type = spec["type"]
+
+        case network_type
+        when "dynamic"
+          if @dynamic_network
+            cloud_error("More than one dynamic network for `#{name}'")
+          else
+            @dynamic_network = DynamicNetwork.new(name, spec)
+            # only extract security groups for dynamic networks
+            extract_security_groups(spec)
+          end
+        when "vip"
+          if @vip_network
+            cloud_error("More than one vip network for `#{name}'")
+          else
+            @vip_network = VipNetwork.new(name, spec)
+          end
+        else
+          cloud_error("Invalid network type `#{network_type}': AWS CPI " \
+                      "can only handle `dynamic' and `vip' network types")
+        end
+
+      end
+
+      if @dynamic_network.nil?
+        cloud_error("At least one dynamic network should be defined")
+      end
+    end
+
+    def configure(ec2, instance)
+      @dynamic_network.configure(ec2, instance)
+
+      if @vip_network
+        @vip_network.configure(ec2, instance)
+      else
+        # If there is no vip network we should disassociate any elastic IP
+        # currently held by instance (as it might have had elastic IP before)
+        elastic_ip = instance.elastic_ip
+
+        if elastic_ip
+          @logger.info("Disassociating elastic IP `#{elastic_ip}' " \
+                       "from instance `#{instance.id}'")
+          instance.disassociate_elastic_ip
+        end
+      end
+    end
+
+    ##
+    # Returns the security groups for this network configuration, or
+    # the default security groups if the configuration does not contain
+    # security groups
+    # @param [Array] default Default security groups
+    # @return [Array] security groups
+    def security_groups(default)
+      if @security_groups.empty? && default
+        return default
+      else
+        return @security_groups
+      end
+    end
+
+    ##
+    # Extracts the security groups from the network configuration
+    # @param [Hash] network_spec Network specification
+    # @raise [ArgumentError] if the security groups in the network_spec
+    #   is not an Array
+    def extract_security_groups(spec)
+      if spec && spec["cloud_properties"]
+        cloud_properties = spec["cloud_properties"]
+        if cloud_properties && cloud_properties["security_groups"]
+          unless cloud_properties["security_groups"].is_a?(Array)
+            raise ArgumentError, "security groups must be an Array"
+          end
+          @security_groups += cloud_properties["security_groups"]
+        end
+      end
+    end
+
+  end
+
+end

data/lib/cloud/aws/registry_client.rb

@@ -0,0 +1,109 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::AwsCloud
+  class RegistryClient
+    include Helpers
+
+    attr_reader :endpoint
+    attr_reader :user
+    attr_reader :password
+
+    def initialize(endpoint, user, password)
+      @endpoint = endpoint
+
+      unless @endpoint =~ /^http:\/\//
+        @endpoint = "http://#{@endpoint}"
+      end
+
+      @user = user
+      @password = password
+
+      auth = Base64.encode64("#{@user}:#{@password}").gsub("\n", "")
+
+      @headers = {
+        "Accept" => "application/json",
+        "Authorization" => "Basic #{auth}"
+      }
+
+      @client = HTTPClient.new
+    end
+
+    ##
+    # Update instance settings in the registry
+    # @param [String] instance_id EC2 instance id
+    # @param [Hash] settings New agent settings
+    # @return [Boolean]
+    def update_settings(instance_id, settings)
+      unless settings.is_a?(Hash)
+        raise ArgumentError, "Invalid settings format, " \
+                             "Hash expected, #{settings.class} given"
+      end
+
+      payload = Yajl::Encoder.encode(settings)
+      url = "#{@endpoint}/instances/#{instance_id}/settings"
+
+      response = @client.put(url, payload, @headers)
+
+      if response.status != 200
+        cloud_error("Cannot update settings for `#{instance_id}', " \
+                    "got HTTP #{response.status}")
+      end
+
+      true
+    end
+
+    ##
+    # Read instance settings from the registry
+    # @param [String] instance_id EC2 instance id
+    # @return [Hash] Agent settings
+    def read_settings(instance_id)
+      url = "#{@endpoint}/instances/#{instance_id}/settings"
+
+      response = @client.get(url, {}, @headers)
+
+      if response.status != 200
+        cloud_error("Cannot read settings for `#{instance_id}', " \
+                    "got HTTP #{response.status}")
+      end
+
+      body = Yajl::Parser.parse(response.body)
+
+      unless body.is_a?(Hash)
+        cloud_error("Invalid registry response, Hash expected, " \
+                    "got #{body.class}: #{body}")
+      end
+
+      settings = Yajl::Parser.parse(body["settings"])
+
+      unless settings.is_a?(Hash)
+        cloud_error("Invalid settings format, " \
+                    "Hash expected, got #{settings.class}: " \
+                    "#{settings}")
+      end
+
+      settings
+
+    rescue Yajl::ParseError
+      cloud_error("Cannot parse settings for `#{instance_id}'")
+    end
+
+    ##
+    # Delete instance settings from the registry
+    # @param [String] instance_id EC2 instance id
+    # @return [Boolean]
+    def delete_settings(instance_id)
+      url = "#{@endpoint}/instances/#{instance_id}/settings"
+
+      response = @client.delete(url, @headers)
+
+      if response.status != 200
+        cloud_error("Cannot delete settings for `#{instance_id}', " \
+                    "got HTTP #{response.status}")
+      end
+
+      true
+    end
+
+  end
+
+end

data/lib/cloud/aws/version.rb

@@ -0,0 +1,7 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh
+  module AwsCloud
+    VERSION = "0.3.3"
+  end
+end

data/lib/cloud/aws/vip_network.rb

@@ -0,0 +1,42 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh::AwsCloud
+  ##
+  #
+  class VipNetwork < Network
+
+    ##
+    # Creates a new vip network
+    #
+    # @param [String] name Network name
+    # @param [Hash] spec Raw network spec
+    def initialize(name, spec)
+      super
+    end
+
+    ##
+    # Configures vip network
+    #
+    # @param [AWS:EC2] ec2 EC2 client
+    # @param [AWS::EC2::Instance] instance EC2 instance to configure
+    def configure(ec2, instance)
+      if @ip.nil?
+        cloud_error("No IP provided for vip network `#{@name}'")
+      end
+
+      @logger.info("Associating instance `#{instance.id}' " \
+                   "with elastic IP `#{@ip}'")
+
+      # New elastic IP reservation supposed to clear the old one,
+      # so no need to disassociate manually. Also, we don't check
+      # if this IP is actually an allocated EC2 elastic IP, as
+      # API call will fail in that case.
+      # TODO: wrap error for non-existing elastic IP?
+      # TODO: poll instance until this IP is returned as its public IP?
+      instance.associate_elastic_ip(@ip)
+    end
+
+  end
+end
+
+

data/lib/cloud/aws.rb

@@ -0,0 +1,33 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh
+  module AwsCloud; end
+end
+
+require "aws-sdk"
+require "httpclient"
+require "pp"
+require "set"
+require "tmpdir"
+require "uuidtools"
+require "yajl"
+
+require "common/thread_pool"
+require "common/thread_formatter"
+
+require "cloud"
+require "cloud/aws/helpers"
+require "cloud/aws/cloud"
+require "cloud/aws/registry_client"
+require "cloud/aws/version"
+
+require "cloud/aws/network_configurator"
+require "cloud/aws/network"
+require "cloud/aws/dynamic_network"
+require "cloud/aws/vip_network"
+
+module Bosh
+  module Clouds
+    Aws = Bosh::AwsCloud::Cloud
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile", __FILE__)
+
+require "rubygems"
+require "bundler"
+Bundler.setup(:default, :test)
+
+require "rspec"
+require "tmpdir"
+
+require "cloud/aws"
+
+class AwsConfig
+  attr_accessor :db, :logger, :uuid
+end
+
+aws_config = AwsConfig.new
+aws_config.db = nil # AWS CPI doesn't need DB
+aws_config.logger = Logger.new(StringIO.new)
+aws_config.logger.level = Logger::DEBUG
+
+Bosh::Clouds::Config.configure(aws_config)
+
+MOCK_AWS_ACCESS_KEY_ID = "foo"
+MOCK_AWS_SECRET_ACCESS_KEY = "bar"
+
+def mock_cloud_options
+  {
+    "aws" => {
+      "access_key_id" => MOCK_AWS_ACCESS_KEY_ID,
+      "secret_access_key" => MOCK_AWS_SECRET_ACCESS_KEY
+    },
+    "registry" => {
+      "endpoint" => "localhost:42288",
+      "user" => "admin",
+      "password" => "admin"
+    },
+    "agent" => {
+      "foo" => "bar",
+      "baz" => "zaz"
+    }
+  }
+end
+
+def make_cloud(options = nil)
+  Bosh::AwsCloud::Cloud.new(options || mock_cloud_options)
+end
+
+def mock_registry(endpoint = "http://registry:3333")
+  registry = mock("registry", :endpoint => endpoint)
+  Bosh::AwsCloud::RegistryClient.stub!(:new).and_return(registry)
+  registry
+end
+
+def mock_cloud(options = nil)
+  instances = double("instances")
+  volumes = double("volumes")
+  images = double("images")
+
+  ec2 = double(AWS::EC2)
+
+  ec2.stub(:instances).and_return(instances)
+  ec2.stub(:volumes).and_return(volumes)
+  ec2.stub(:images).and_return(images)
+
+  AWS::EC2.stub(:new).and_return(ec2)
+
+  yield ec2 if block_given?
+
+  Bosh::AwsCloud::Cloud.new(options || mock_cloud_options)
+end
+
+def dynamic_network_spec
+  { "type" => "dynamic" }
+end
+
+def vip_network_spec
+  {
+    "type" => "vip",
+    "ip" => "10.0.0.1"
+  }
+end
+
+def combined_network_spec
+  {
+    "network_a" => dynamic_network_spec,
+    "network_b" => vip_network_spec
+  }
+end
+
+def resource_pool_spec
+  {
+    "key_name" => "test_key",
+    "availability_zone" => "foobar-1a",
+    "instance_type" => "m3.zb"
+  }
+end
+
+