bosh_cpi 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 99a4eed7d57155aaab71e8d3d96ba913ca1c3dd7
-  data.tar.gz: 989cf2cf09fb1a47addb39348441be1d9f10fb87
+  metadata.gz: 77f9ed40e596e15952e7c43452f19682c0e1ea83
+  data.tar.gz: 9939c9c1db5797ee1311541d2e8d34ab63dc6d14
 SHA512:
-  metadata.gz: dc58193908a9b31b1a0eb6d03d6f6a93e8b9fa95c318691d017a5d9853d264c0c37577333c6ab052a54681861507a46a6e8da9cfc29c46a98a524f0e4e73e57f
-  data.tar.gz: f415c989376f1cbd0eac4388a7da3ec57964af26467e7d84da3d3217fdf184a4e103d6e3b0a7bb1034a28cb80effa9fa77bfda7fb27d6290426bb97406070cba
+  metadata.gz: c889201fd88c6abbbb1cb77b4fc123dc1f49398dff060907f5ed1e9d9c79e6999fd2f94aebeb0a644fcfaeb9cebc094d67557791ded96b03ef358a05f5b4f086
+  data.tar.gz: 98d595503bd95bb1e477bd7ba47529f675e34d7d574e152276ba9c9147595c629cef76567819a763b0abe7659a5b873da0a6dd3706d5c3d89569eb40e9f43318

data/lib/bosh/cpi/cli.rb

@@ -0,0 +1,129 @@
+require 'json'
+
+class Bosh::Cpi::Cli
+  KNOWN_RPC_METHODS = %w(
+    current_vm_id
+    create_stemcell
+    delete_stemcell
+    create_vm
+    delete_vm
+    has_vm
+    reboot_vm
+    set_vm_metadata
+    create_disk
+    has_disk
+    delete_disk
+    attach_disk
+    detach_disk
+    snapshot_disk
+    delete_snapshot
+    get_disks
+    ping
+    calculate_vm_cloud_properties
+  ).freeze
+
+  RPC_METHOD_TO_RUBY_METHOD = {
+    'has_vm' => 'has_vm?',
+    'has_disk' => 'has_disk?',
+  }.freeze
+
+  INVALID_CALL_ERROR_TYPE = 'InvalidCall'.freeze
+  UNKNOWN_ERROR_TYPE      = 'Unknown'.freeze
+
+  def initialize(cpi, logs_string_io, result_io)
+    @cpi = cpi
+    @logs_string_io = logs_string_io
+    @result_io = result_io
+  end
+
+  def run(json)
+    begin
+      request = JSON.load(json)
+    rescue JSON::ParserError => e
+      return error_response(INVALID_CALL_ERROR_TYPE, "Request cannot be deserialized, details: #{e.message}", false, e.backtrace)
+    end
+
+    method = request['method']
+    unless method.is_a?(String)
+      return error_response(INVALID_CALL_ERROR_TYPE, "Method must be a String, got: '#{method.inspect}'", false)
+    end
+
+    unless KNOWN_RPC_METHODS.include?(method)
+      return error_response(INVALID_CALL_ERROR_TYPE, "Method is not known, got: '#{method}'", false)
+    end
+
+    arguments = request['arguments']
+    unless arguments.is_a?(Array)
+      return error_response(INVALID_CALL_ERROR_TYPE, "Arguments must be an Array, got: '#{arguments.inspect}'", false)
+    end
+
+    context = request['context']
+    unless context.is_a?(Hash) && context['director_uuid'].is_a?(String)
+      return error_response(INVALID_CALL_ERROR_TYPE, "Request should include context with director uuid, got: '#{context.inspect}'", false)
+    end
+
+    configure_director(context['director_uuid'])
+
+    ruby_method = RPC_METHOD_TO_RUBY_METHOD[method] || method
+
+    begin
+      cpi = @cpi.call(context)
+      result = cpi.public_send(ruby_method, *arguments)
+    rescue Bosh::Clouds::RetriableCloudError => e
+      return error_response(error_name(e), e.message, e.ok_to_retry, e.backtrace)
+    rescue Bosh::Clouds::CloudError, Bosh::Clouds::CpiError => e
+      return error_response(error_name(e), e.message, false, e.backtrace)
+    rescue ArgumentError => e
+      return error_response(INVALID_CALL_ERROR_TYPE, "Arguments are not correct, details: '#{e.message}'", false, e.backtrace)
+    rescue Exception => e
+      return error_response(UNKNOWN_ERROR_TYPE, e.message, false, e.backtrace)
+    end
+
+    result_response(result)
+  end
+
+  private
+
+  def configure_director(director_uuid)
+    Bosh::Clouds::Config.uuid = director_uuid
+  end
+
+  def error_response(type, message, ok_to_retry, bt=[])
+    if !bt.empty?
+      @logs_string_io.print("Rescued #{type}: #{message}. backtrace: #{bt.join("\n")}")
+    end
+
+    hash = {
+      result: nil,
+      error: {
+        type: type,
+        message: message,
+        ok_to_retry: ok_to_retry,
+      },
+      log: encode_string_as_utf8(@logs_string_io.string)
+    }
+    @result_io.print(JSON.dump(hash)); nil
+  end
+
+  def result_response(result)
+    hash = {
+      result: result,
+      error: nil,
+      log: encode_string_as_utf8(@logs_string_io.string)
+    }
+    @result_io.print(JSON.dump(hash)); nil
+  end
+
+  def error_name(error)
+    error.class.name
+  end
+
+  def encode_string_as_utf8(src)
+    log = @logs_string_io.string.force_encoding(Encoding::UTF_8)
+    unless log.valid_encoding?
+      # the src encoding hint of Encoding::BINARY is only required for ruby 1.9.3
+      log = @logs_string_io.string.encode(Encoding::UTF_8, Encoding::BINARY, undef: :replace, invalid: :replace)
+    end
+    log
+  end
+end

data/lib/bosh/cpi/compatibility_helpers/delete_vm.rb

@@ -0,0 +1,15 @@
+require 'bosh/cpi/compatibility_helpers'
+
+module Bosh::Cpi::CompatibilityHelpers
+  def it_can_delete_non_existent_vm(vm_cid='vm-cid')
+    describe "delete_vm (deleting non existent vm)" do
+      context "when VM is not present" do
+        it "raises VMNotFound error" do
+          expect {
+            cpi.delete_vm(vm_cid)
+          }.to raise_error(Bosh::Clouds::VMNotFound, "VM '#{vm_cid}' not found")
+        end
+      end
+    end
+  end
+end

data/lib/bosh/cpi/compatibility_helpers.rb

@@ -0,0 +1,5 @@
+require 'bosh/cpi'
+
+module Bosh::Cpi
+  module CompatibilityHelpers; end
+end

data/lib/bosh/cpi/registry_client.rb

@@ -0,0 +1,106 @@
+require 'cloud/errors'
+require 'httpclient'
+require 'base64'
+require 'json'
+
+module Bosh::Cpi
+  class RegistryClient
+    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 = JSON.dump(settings)
+      url = "#{@endpoint}/instances/#{instance_id}/settings"
+
+      response = @client.put(url, {:body => payload, :header => @headers})
+
+      unless HTTP::Status.successful?(response.status)
+        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, {:header => @headers})
+
+      if response.status != 200
+        cloud_error("Cannot read settings for '#{instance_id}', got HTTP #{response.status}")
+      end
+
+      body = JSON.load(response.body)
+
+      unless body.is_a?(Hash)
+        cloud_error("Invalid registry response, Hash expected, got #{body.class}: #{body}")
+      end
+
+      settings = JSON.load(body["settings"])
+
+      unless settings.is_a?(Hash)
+        cloud_error("Invalid settings format, Hash expected, got #{settings.class}: #{settings}")
+      end
+
+      settings
+    rescue JSON::ParserError => e
+      cloud_error("Cannot parse settings for '#{instance_id}': #{e.message}")
+    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, {:header => @headers})
+
+      unless [200, 404].include? response.status
+        cloud_error("Cannot delete settings for '#{instance_id}', got HTTP #{response.status}")
+      end
+
+      true
+    end
+
+    private
+
+    def cloud_error(message)
+      raise Bosh::Clouds::CloudError, message
+    end
+  end
+end

data/lib/bosh/cpi/tasks/spec.rake

@@ -0,0 +1,10 @@
+require 'rspec'
+require 'rspec/core/rake_task'
+
+namespace :spec do
+  desc 'Run VM lifecycle specs'
+  RSpec::Core::RakeTask.new(:lifecycle) do |t|
+    t.pattern = 'spec/integration'
+    t.rspec_opts = %w(--format documentation --color)
+  end
+end

data/lib/bosh/cpi/tasks.rb

@@ -0,0 +1 @@
+Dir.glob(File.expand_path('tasks/**/*.rake', File.dirname(__FILE__))).each { |r| import r }

data/lib/bosh/cpi.rb

@@ -0,0 +1,6 @@
+module Bosh
+  module Cpi; end
+end
+
+require 'bosh/cpi/cli'
+require 'bosh/cpi/registry_client'

data/lib/cloud/config.rb

@@ -0,0 +1,17 @@
+require 'forwardable'
+
+module Bosh::Clouds
+  class Config
+
+    class << self
+      extend Forwardable
+      def_delegators :@delegate, :db, :logger, :uuid, :uuid=, :task_checkpoint, :cpi_task_log
+    end
+
+    # @param [Bosh::Director::Config] config director config file
+    def self.configure(config)
+      @delegate = config
+    end
+
+  end
+end

data/lib/cloud/errors.rb

@@ -0,0 +1,21 @@
+module Bosh::Clouds
+  class CpiError < StandardError; end
+  class NotImplemented < CpiError; end
+  class NotSupported < CpiError; end
+
+  class CloudError < StandardError; end
+  class VMNotFound < CloudError; end
+
+  class RetriableCloudError < CloudError
+    attr_accessor :ok_to_retry
+
+    def initialize(ok_to_retry)
+      @ok_to_retry = ok_to_retry
+    end
+  end
+
+  class NoDiskSpace < RetriableCloudError; end
+  class DiskNotAttached < RetriableCloudError; end
+  class DiskNotFound < RetriableCloudError; end
+  class VMCreationFailed < RetriableCloudError; end
+end

data/lib/cloud/external_cpi.rb

@@ -0,0 +1,163 @@
+require 'membrane'
+require 'open3'
+
+module Bosh::Clouds
+  class ExternalCpi
+    # Raised when the external CPI executable returns an error unknown to director
+    class UnknownError < StandardError; end
+
+    # Raised when the external CPI executable returns nil or invalid JSON format to director
+    class InvalidResponse < StandardError; end
+
+    # Raised when the external CPI bin/cpi is not executable
+    class NonExecutable < StandardError; end
+
+    KNOWN_RPC_ERRORS = %w(
+      Bosh::Clouds::CpiError
+      Bosh::Clouds::NotSupported
+      Bosh::Clouds::NotImplemented
+
+      Bosh::Clouds::CloudError
+      Bosh::Clouds::VMNotFound
+
+      Bosh::Clouds::NoDiskSpace
+      Bosh::Clouds::DiskNotAttached
+      Bosh::Clouds::DiskNotFound
+      Bosh::Clouds::VMCreationFailed
+    ).freeze
+
+    RESPONSE_SCHEMA = Membrane::SchemaParser.parse do
+      {
+        'result' => any,
+        'error' => enum(nil,
+          { 'type' => String,
+            'message' => String,
+            'ok_to_retry' => bool
+          }
+        ),
+        'log' => String
+      }
+    end
+
+    def initialize(cpi_path, director_uuid, properties_from_cpi_config = nil)
+      @cpi_path = cpi_path
+      @director_uuid = director_uuid
+      @logger = Config.logger
+      @properties_from_cpi_config = properties_from_cpi_config
+    end
+
+    def current_vm_id(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+    def create_stemcell(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+    def delete_stemcell(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+    def create_vm(*arguments) invoke_cpi_method(__method__.to_s, *arguments); end
+    def delete_vm(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+    def has_vm?(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+    def reboot_vm(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+    def set_vm_metadata(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+    def create_disk(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+    def has_disk?(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+    def delete_disk(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+    def attach_disk(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+    def detach_disk(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+    def snapshot_disk(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+    def delete_snapshot(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+    def get_disks(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+    def ping(*arguments); invoke_cpi_method(__method__.to_s, *arguments); end
+
+    private
+
+    def invoke_cpi_method(method_name, *arguments)
+      context = {
+          'director_uuid' => @director_uuid
+      }
+      context.merge!(@properties_from_cpi_config) unless @properties_from_cpi_config.nil?
+
+      request = request_json(method_name, arguments, context)
+      redacted_request = request_json(method_name, arguments, redact_context(context))
+
+      env = {'PATH' => '/usr/sbin:/usr/bin:/sbin:/bin', 'TMPDIR' => ENV['TMPDIR']}
+      cpi_exec_path = checked_cpi_exec_path
+
+      @logger.debug("External CPI sending request: #{redacted_request} with command: #{cpi_exec_path}")
+      cpi_response, stderr, exit_status = Open3.capture3(env, cpi_exec_path, stdin_data: request, unsetenv_others: true)
+      @logger.debug("External CPI got response: #{cpi_response}, err: #{stderr}, exit_status: #{exit_status}")
+
+      parsed_response = parsed_response(cpi_response)
+      validate_response(parsed_response)
+
+      if parsed_response['error']
+        handle_error(parsed_response['error'], method_name)
+      end
+
+      save_cpi_log(parsed_response['log'])
+      save_cpi_log(stderr)
+
+      parsed_response['result']
+    end
+
+    def checked_cpi_exec_path
+      unless File.executable?(@cpi_path)
+        raise NonExecutable, "Failed to run cpi: '#{@cpi_path}' is not executable"
+      end
+      @cpi_path
+    end
+
+    def redact_context(context)
+      return context if @properties_from_cpi_config.nil?
+      Hash[context.map{|k,v|[k,@properties_from_cpi_config.keys.include?(k) ? '<redacted>' : v]}]
+    end
+
+    def request_json(method_name, arguments, context)
+      JSON.dump({
+                    'method' => method_name.gsub(/\?$/,''),
+                    'arguments' => arguments,
+                    'context' => context
+                })
+    end
+
+    def handle_error(error_response, method_name)
+      error_type = error_response['type']
+      error_message = error_response['message']
+      unless KNOWN_RPC_ERRORS.include?(error_type)
+        raise UnknownError, "Unknown CPI error '#{error_type}' with message '#{error_message}' in '#{method_name}' CPI method"
+      end
+
+      error_class = constantize(error_type)
+
+      if error_class <= RetriableCloudError
+        error = error_class.new(error_response['ok_to_retry'])
+      else
+        error = error_class.new(error_message)
+      end
+
+      raise error, "CPI error '#{error_type}' with message '#{error_message}' in '#{method_name}' CPI method"
+    end
+
+    def save_cpi_log(output)
+      # cpi log path is set up at the beginning of every task in Config
+      # see JobRunner#setup_task_logging
+      File.open(Config.cpi_task_log, 'a') do |f|
+        f.write(output)
+      end
+    end
+
+    def parsed_response(input)
+      begin
+        JSON.load(input)
+      rescue JSON::ParserError => e
+        raise InvalidResponse, "Invalid CPI response - ParserError - #{e.message}"
+      end
+    end
+
+    def validate_response(response)
+      RESPONSE_SCHEMA.validate(response)
+    rescue Membrane::SchemaValidationError => e
+      raise InvalidResponse, "Invalid CPI response - SchemaValidationError: #{e.message}"
+    end
+
+    def constantize(camel_cased_word)
+      error_name = camel_cased_word.split('::').last
+      Bosh::Clouds.const_get(error_name)
+    end
+  end
+end

data/lib/cloud/internal_cpi.rb

@@ -0,0 +1,25 @@
+module Bosh::Clouds
+  class InternalCpi
+    def initialize(cloud)
+      @cloud = cloud
+    end
+
+    private
+
+    def method_missing(method_sym, *arguments, &block)
+      invoke_cpi_method(method_sym, arguments)
+    end
+
+    def respond_to?(method_sym)
+      cloud.respond_to?(method_sym)
+    end
+
+    def cloud
+      @cloud
+    end
+
+    def invoke_cpi_method(method_sym, arguments)
+      cloud.send(method_sym, *JSON.parse(JSON.dump(arguments)))
+    end
+  end
+end

data/lib/cloud/provider.rb

@@ -0,0 +1,31 @@
+module Bosh::Clouds
+  class Provider
+    def self.create(cloud_config, director_uuid)
+      if cloud_config.has_key?('provider')
+        ExternalCpiProvider.create(cloud_config['provider']['path'], director_uuid)
+      else
+        InternalCpiProvider.create(cloud_config['plugin'], cloud_config['properties'])
+      end
+    end
+  end
+
+  private
+
+  class InternalCpiProvider
+    def self.create(plugin, options)
+      begin
+        require "cloud/#{plugin}"
+      rescue LoadError => error
+        raise CloudError, "Could not load Cloud Provider Plugin: #{plugin}, with error #{error.inspect}"
+      end
+
+      InternalCpi.new(Bosh::Clouds.const_get(plugin.capitalize).new(options))
+    end
+  end
+
+  class ExternalCpiProvider
+    def self.create(cpi_job_path, director_uuid)
+      ExternalCpi.new(cpi_job_path, director_uuid)
+    end
+  end
+end

data/lib/cloud/version.rb

@@ -0,0 +1,5 @@
+module Bosh
+  module Clouds
+    VERSION = '2.0.1'
+  end
+end

data/lib/cloud.rb

@@ -0,0 +1,229 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh; module Clouds; end; end
+
+require "forwardable"
+
+require "cloud/config"
+require "cloud/errors"
+require "cloud/provider"
+require "cloud/external_cpi"
+require "cloud/internal_cpi"
+
+module Bosh
+
+  ##
+  # CPI - Cloud Provider Interface, used for interfacing with various IaaS APIs.
+  #
+  # Key terms:
+  # Stemcell: template used for creating VMs (shouldn't be powered on)
+  # VM:       VM created from a stemcell with custom settings (networking and resources)
+  # Disk:     volume that can be attached and detached from the VMs,
+  #           never attached to more than a single VM at one time
+  class Cloud
+
+    ##
+    # Cloud initialization
+    #
+    # @param [Hash] options cloud options
+    def initialize(options)
+    end
+
+    ##
+    # Get the vm_id of this host
+    #
+    # @return [String] opaque id later used by other methods of the CPI
+    def current_vm_id
+      not_implemented(:current_vm_id)
+    end
+
+    ##
+    # Creates a stemcell
+    #
+    # @param [String] image_path path to an opaque blob containing the stemcell image
+    # @param [Hash] cloud_properties properties required for creating this template
+    #               specific to a CPI
+    # @return [String] opaque id later used by {#create_vm} and {#delete_stemcell}
+    def create_stemcell(image_path, cloud_properties)
+      not_implemented(:create_stemcell)
+    end
+
+    ##
+    # Deletes a stemcell
+    #
+    # @param [String] stemcell stemcell id that was once returned by {#create_stemcell}
+    # @return [void]
+    def delete_stemcell(stemcell_id)
+      not_implemented(:delete_stemcell)
+    end
+
+    ##
+    # Creates a VM - creates (and powers on) a VM from a stemcell with the proper resources
+    # and on the specified network. When disk locality is present the VM will be placed near
+    # the provided disk so it won't have to move when the disk is attached later.
+    #
+    # Sample networking config:
+    #  {"network_a" =>
+    #    {
+    #      "netmask"          => "255.255.248.0",
+    #      "ip"               => "172.30.41.40",
+    #      "gateway"          => "172.30.40.1",
+    #      "dns"              => ["172.30.22.153", "172.30.22.154"],
+    #      "cloud_properties" => {"name" => "VLAN444"}
+    #    }
+    #  }
+    #
+    # Sample resource pool config (CPI specific):
+    #  {
+    #    "ram"  => 512,
+    #    "disk" => 512,
+    #    "cpu"  => 1
+    #  }
+    # or similar for EC2:
+    #  {"name" => "m1.small"}
+    #
+    # @param [String] agent_id UUID for the agent that will be used later on by the director
+    #                 to locate and talk to the agent
+    # @param [String] stemcell stemcell id that was once returned by {#create_stemcell}
+    # @param [Hash] resource_pool cloud specific properties describing the resources needed
+    #               for this VM
+    # @param [Hash] networks list of networks and their settings needed for this VM
+    # @param [String, Array] disk_locality disk id(s) if known of the disk(s) that will be
+    #                                    attached to this vm
+    # @param [Hash] env environment that will be passed to this vm
+    # @return [String] opaque id later used by {#attach_disk}, {#detach_disk} and {#delete_vm}
+    def create_vm(agent_id, stemcell_id, resource_pool,
+                  networks, disk_locality, env)
+      not_implemented(:create_vm)
+    end
+
+    ##
+    # Deletes a VM. If the VM has already been deleted, this call returns normally and has no effect.
+    #
+    # @param [String] vm vm id that was once returned by {#create_vm}
+    # @return [void]
+    def delete_vm(vm_id)
+      not_implemented(:delete_vm)
+    end
+
+    ##
+    # Checks if a VM exists
+    #
+    # @param [String] vm vm id that was once returned by {#create_vm}
+    # @return [Boolean] True if the vm exists
+    def has_vm?(vm_id)
+      not_implemented(:has_vm?)
+    end
+
+    ##
+    # Checks if a disk exists
+    #
+    # @param [String] disk disk_id that was once returned by {#create_disk}
+    # @return [Boolean] True if the disk exists
+    def has_disk?(disk_id)
+      not_implemented(:has_disk?)
+    end
+
+    ##
+    # Reboots a VM
+    #
+    # @param [String] vm vm id that was once returned by {#create_vm}
+    # @param [Optional, Hash] CPI specific options (e.g hard/soft reboot)
+    # @return [void]
+    def reboot_vm(vm_id)
+      not_implemented(:reboot_vm)
+    end
+
+    ##
+    # Set metadata for a VM
+    #
+    # Optional. Implement to provide more information for the IaaS.
+    #
+    # @param [String] vm vm id that was once returned by {#create_vm}
+    # @param [Hash] metadata metadata key/value pairs
+    # @return [void]
+    def set_vm_metadata(vm, metadata)
+      not_implemented(:set_vm_metadata)
+    end
+
+    ##
+    # Creates a disk (possibly lazily) that will be attached later to a VM. When
+    # VM locality is specified the disk will be placed near the VM so it won't have to move
+    # when it's attached later.
+    #
+    # @param [Integer] size disk size in MB
+    # @param [Hash] cloud_properties properties required for creating this disk
+    #               specific to a CPI
+    # @param [String] vm_locality vm id if known of the VM that this disk will
+    #                           be attached to
+    # @return [String] opaque id later used by {#attach_disk}, {#detach_disk}, and {#delete_disk}
+    def create_disk(size, cloud_properties, vm_locality)
+      not_implemented(:create_disk)
+    end
+
+    ##
+    # Deletes a disk
+    # Will raise an exception if the disk is attached to a VM
+    #
+    # @param [String] disk disk id that was once returned by {#create_disk}
+    # @return [void]
+    def delete_disk(disk_id)
+      not_implemented(:delete_disk)
+    end
+
+    # Attaches a disk
+    # @param [String] vm vm id that was once returned by {#create_vm}
+    # @param [String] disk disk id that was once returned by {#create_disk}
+    # @return [void]
+    def attach_disk(vm_id, disk_id)
+      not_implemented(:attach_disk)
+    end
+
+    # Take snapshot of disk
+    # @param [String] disk_id disk id of the disk to take the snapshot of
+    # @param [Hash] metadata metadata key/value pairs
+    # @return [String] snapshot id
+    def snapshot_disk(disk_id, metadata)
+      not_implemented(:snapshot_disk)
+    end
+
+    # Delete a disk snapshot
+    # @param [String] snapshot_id snapshot id to delete
+    # @return [void]
+    def delete_snapshot(snapshot_id)
+      not_implemented(:delete_snapshot)
+    end
+
+    # Detaches a disk
+    # @param [String] vm vm id that was once returned by {#create_vm}
+    # @param [String] disk disk id that was once returned by {#create_disk}
+    # @return [void]
+    def detach_disk(vm_id, disk_id)
+      not_implemented(:detach_disk)
+    end
+
+    # List the attached disks of the VM.
+    # @param [String] vm_id is the CPI-standard vm_id (eg, returned from current_vm_id)
+    # @return [array[String]] list of opaque disk_ids that can be used with the
+    # other disk-related methods on the CPI
+    def get_disks(vm_id)
+      not_implemented(:get_disks)
+    end
+
+    # Specify VM's hardware resources
+    # @param [Hash] vm_properties (typically cpu, ram, ephemeral_disk_size)
+    # @return [Hash] opaque description of the VM's configuration that
+    # can be used with {#create_vm}
+    def calculate_vm_cloud_properties(vm_properties)
+      not_implemented(:calculate_vm_cloud_properties)
+    end
+
+    private
+
+    def not_implemented(method)
+      raise Bosh::Clouds::NotImplemented,
+            "'#{method}' is not implemented by #{self.class}"
+    end
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bosh_cpi
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - VMware
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-10 00:00:00.000000000 Z
+date: 2016-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bosh_common
@@ -57,7 +57,21 @@ email: support@cloudfoundry.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/bosh/cpi.rb
+- lib/bosh/cpi/cli.rb
+- lib/bosh/cpi/compatibility_helpers.rb
+- lib/bosh/cpi/compatibility_helpers/delete_vm.rb
+- lib/bosh/cpi/registry_client.rb
+- lib/bosh/cpi/tasks.rb
+- lib/bosh/cpi/tasks/spec.rake
+- lib/cloud.rb
+- lib/cloud/config.rb
+- lib/cloud/errors.rb
+- lib/cloud/external_cpi.rb
+- lib/cloud/internal_cpi.rb
+- lib/cloud/provider.rb
+- lib/cloud/version.rb
 homepage: https://github.com/cloudfoundry/bosh
 licenses:
 - Apache 2.0