bosh_openstack_cpi 0.0.2

data/lib/cloud/openstack/dynamic_network.rb

@@ -0,0 +1,26 @@
+# Copyright (c) 2012 Piston Cloud Computing, Inc.
+
+module Bosh::OpenStackCloud
+  ##
+  #
+  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 OpenStack dynamic network. Right now it's a no-op,
+    # as dynamic networks are completely managed by OpenStack
+    # @param [Fog::Compute::OpenStack] openstack Fog OpenStack Compute client
+    # @param [Fog::Compute::OpenStack::Server] server OpenStack server to configure
+    def configure(openstack, server)
+    end
+
+  end
+end

data/lib/cloud/openstack/helpers.rb

@@ -0,0 +1,49 @@
+# Copyright (c) 2012 Piston Cloud Computing, Inc.
+
+module Bosh::OpenStackCloud
+
+  module Helpers
+
+    DEFAULT_TIMEOUT = 3600
+
+    #
+    # Raises CloudError exception
+    #
+    def cloud_error(message)
+      @logger.error(message) if @logger
+      raise Bosh::Clouds::CloudError, message
+    end
+
+    #
+    # Waits for a resource to be on a target state
+    #
+    def wait_resource(resource, start_state, target_state, state_method = :status, timeout = DEFAULT_TIMEOUT)
+
+      started_at = Time.now
+      state = resource.send(state_method).downcase rescue state_method
+      desc = resource.class.name.split("::").last.to_s + " " + resource.id.to_s
+
+      while state.to_sym != target_state
+        duration = Time.now - started_at
+
+        if duration > timeout
+          cloud_error("Timed out waiting for #{desc} to be #{target_state}")
+        end
+
+        @logger.debug("Waiting for #{desc} to be #{target_state} (#{duration})") if @logger
+
+        sleep(1)
+
+        if resource.reload.nil?
+          state = target_state
+        else
+          state = resource.send(state_method).downcase rescue state_method
+        end
+      end
+
+      @logger.info("#{desc} is #{target_state} after #{Time.now - started_at}s") if @logger
+    end
+
+  end
+
+end

data/lib/cloud/openstack/network.rb

@@ -0,0 +1,37 @@
+# Copyright (c) 2012 Piston Cloud Computing, Inc.
+
+module Bosh::OpenStackCloud
+  ##
+  #
+  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 server
+    #
+    # @param [Fog::Compute::OpenStack] openstack Fog OpenStack Compute client
+    # @param [Fog::Compute::OpenStack::Server] server OpenStack server to configure
+    def configure(openstack, server)
+      cloud_error("`configure' not implemented by #{self.class}")
+    end
+
+  end
+end

data/lib/cloud/openstack/network_configurator.rb

@@ -0,0 +1,113 @@
+# Copyright (c) 2012 Piston Cloud Computing, Inc.
+
+module Bosh::OpenStackCloud
+  ##
+  # Represents OpenStack server network config. OpenStack server has single NIC
+  # with dynamic IP address and (optionally) a single floating IP address
+  # which server 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 OpenStack 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}': OpenStack 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(openstack, server)
+      @dynamic_network.configure(openstack, server)
+
+      if @vip_network
+        @vip_network.configure(openstack, server)
+      else
+        # If there is no vip network we should disassociate any floating IP
+        # currently held by server (as it might have had floating IP before)
+        addresses = openstack.addresses
+        addresses.each do |address|
+          if address.instance_id == server.id
+            @logger.info("Disassociating floating IP `#{address.ip}' " \
+                         "from server `#{server.id}'")
+            address.server = nil
+          end
+        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/openstack/registry_client.rb

@@ -0,0 +1,109 @@
+# Copyright (c) 2012 Piston Cloud Computing, Inc.
+
+module Bosh::OpenStackCloud
+  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 server settings in the registry
+    # @param [String] server_id OpenStack server id
+    # @param [Hash] settings New agent settings
+    # @return [Boolean]
+    def update_settings(server_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}/servers/#{server_id}/settings"
+
+      response = @client.put(url, payload, @headers)
+
+      if response.status != 200
+        cloud_error("Cannot update settings for `#{server_id}', " \
+                    "got HTTP #{response.status}")
+      end
+
+      true
+    end
+
+    ##
+    # Read server settings from the registry
+    # @param [String] server_id OpenStack server id
+    # @return [Hash] Agent settings
+    def read_settings(server_id)
+      url = "#{@endpoint}/servers/#{server_id}/settings"
+
+      response = @client.get(url, {}, @headers)
+
+      if response.status != 200
+        cloud_error("Cannot read settings for `#{server_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 `#{server_id}'")
+    end
+
+    ##
+    # Delete server settings from the registry
+    # @param [String] server_id OpenStack server id
+    # @return [Boolean]
+    def delete_settings(server_id)
+      url = "#{@endpoint}/servers/#{server_id}/settings"
+
+      response = @client.delete(url, @headers)
+
+      if response.status != 200
+        cloud_error("Cannot delete settings for `#{server_id}', " \
+                    "got HTTP #{response.status}")
+      end
+
+      true
+    end
+
+  end
+
+end

data/lib/cloud/openstack/version.rb

@@ -0,0 +1,7 @@
+# Copyright (c) 2012 Piston Cloud Computing, Inc.
+
+module Bosh
+  module OpenStackCloud
+    VERSION = "0.0.2"
+  end
+end

data/lib/cloud/openstack/vip_network.rb

@@ -0,0 +1,49 @@
+# Copyright (c) 2012 Piston Cloud Computing, Inc.
+
+module Bosh::OpenStackCloud
+  ##
+  #
+  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 [Fog::Compute::OpenStack] openstack Fog OpenStack Compute client
+    # @param [Fog::Compute::OpenStack::Server] server OpenStack server to configure
+    def configure(openstack, server)
+      if @ip.nil?
+        cloud_error("No IP provided for vip network `#{@name}'")
+      end
+
+      @logger.info("Associating server `#{server.id}' " \
+                   "with floating IP `#{@ip}'")
+
+      # Check if the OpenStack floating IP is allocated. If true, check
+      # if it is associated to any server, so we can disassociate it
+      # before associating it to the new server.
+      address_id = nil
+      addresses = openstack.addresses
+      addresses.each do |address|
+        if address.ip == @ip
+          address.server = nil unless address.instance_id.nil?
+          address.server = server
+          address_id = address.id
+          break
+        end
+      end
+      if address_id.nil?
+        cloud_error("OpenStack CPI: floating IP #{@ip} not allocated")
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,137 @@
+# Copyright (c) 2012 Piston Cloud Computing, Inc.
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile", __FILE__)
+
+require "rubygems"
+require "bundler"
+
+Bundler.setup(:default, :test)
+
+require "rspec"
+require "tmpdir"
+
+require "cloud/openstack"
+
+class OpenStackConfig
+  attr_accessor :db, :logger, :uuid
+end
+
+os_config = OpenStackConfig.new
+os_config.db = nil # OpenStack CPI doesn't need DB
+os_config.logger = Logger.new(StringIO.new)
+os_config.logger.level = Logger::DEBUG
+
+Bosh::Clouds::Config.configure(os_config)
+
+def internal_to(*args, &block)
+  example = describe *args, &block
+  klass = args[0]
+  if klass.is_a? Class
+    saved_private_instance_methods = klass.private_instance_methods
+    example.before do
+      klass.class_eval { public *saved_private_instance_methods }
+    end
+    example.after do
+      klass.class_eval { private *saved_private_instance_methods }
+    end
+  end
+end
+
+def mock_cloud_options
+  {
+    "openstack" => {
+      "auth_url" => "http://127.0.0.1:5000/v2.0/tokens",
+      "username" => "admin",
+      "api_key" => "nova",
+      "tenant" => "admin"
+    },
+    "registry" => {
+      "endpoint" => "localhost:42288",
+      "user" => "admin",
+      "password" => "admin"
+    },
+    "agent" => {
+      "foo" => "bar",
+      "baz" => "zaz"
+    }
+  }
+end
+
+def make_cloud(options = nil)
+  Bosh::OpenStackCloud::Cloud.new(options || mock_cloud_options)
+end
+
+def mock_registry(endpoint = "http://registry:3333")
+  registry = mock("registry", :endpoint => endpoint)
+  Bosh::OpenStackCloud::RegistryClient.stub!(:new).and_return(registry)
+  registry
+end
+
+def mock_cloud(options = nil)
+  servers = double("servers")
+  images = double("images")
+  flavors = double("flavors")
+  volumes = double("volumes")
+  addresses = double("addresses")
+  snapshots = double("snapshots")
+
+  glance = double(Fog::Image)
+  Fog::Image.stub(:new).and_return(glance)
+
+  openstack = double(Fog::Compute)
+
+  openstack.stub(:servers).and_return(servers)
+  openstack.stub(:images).and_return(images)
+  openstack.stub(:flavors).and_return(flavors)
+  openstack.stub(:volumes).and_return(volumes)
+  openstack.stub(:addresses).and_return(addresses)
+  openstack.stub(:snapshots).and_return(snapshots)
+
+  Fog::Compute.stub(:new).and_return(openstack)
+
+  yield openstack if block_given?
+
+  Bosh::OpenStackCloud::Cloud.new(options || mock_cloud_options)
+end
+
+def mock_glance(options = nil)
+  images = double("images")
+
+  openstack = double(Fog::Compute)
+  Fog::Compute.stub(:new).and_return(openstack)
+
+  glance = double(Fog::Image)
+  glance.stub(:images).and_return(images)
+
+  Fog::Image.stub(:new).and_return(glance)
+
+  yield glance if block_given?
+
+  Bosh::OpenStackCloud::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" => "m1.tiny"
+  }
+end