bosh_cpi 1.3262.24.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 861bc0bb0525e4574f06fb83c9b6b43c2f28bfdc
-  data.tar.gz: 9963447a1415ee8926d387575ad0b1857e82576a
+  metadata.gz: 99a4eed7d57155aaab71e8d3d96ba913ca1c3dd7
+  data.tar.gz: 989cf2cf09fb1a47addb39348441be1d9f10fb87
 SHA512:
-  metadata.gz: 879d8ad1d5dc2d76cb49d628117cf17863313b83cbd93c16c81633052d7dcb826f9f39e43a398d2e0ecf51521400c8aeb219b8a75c7cd1d3e95f981bf3d633ab
-  data.tar.gz: 5693673653b01a64b7e0ef152e4e1c9a427c3bddadf1f1fae3b8259b127bfdfe7e9aff794f13281ca6bd90eb127d1bb6fde177ad8b11392469543dfb0c4170ea
+  metadata.gz: dc58193908a9b31b1a0eb6d03d6f6a93e8b9fa95c318691d017a5d9853d264c0c37577333c6ab052a54681861507a46a6e8da9cfc29c46a98a524f0e4e73e57f
+  data.tar.gz: f415c989376f1cbd0eac4388a7da3ec57964af26467e7d84da3d3217fdf184a4e103d6e3b0a7bb1034a28cb80effa9fa77bfda7fb27d6290426bb97406070cba

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bosh_cpi
 version: !ruby/object:Gem::Version
-  version: 1.3262.24.0
+  version: 2.0.0
 platform: ruby
 authors:
 - VMware
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-02 00:00:00.000000000 Z
+date: 2016-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bosh_common
@@ -52,68 +52,12 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.8.2
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec-its
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: BOSH CPI
 email: support@cloudfoundry.com
 executables: []
 extensions: []
 extra_rdoc_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
+files: []
 homepage: https://github.com/cloudfoundry/bosh
 licenses:
 - Apache 2.0
@@ -134,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: BOSH CPI

data/lib/bosh/cpi/cli.rb

@@ -1,119 +0,0 @@
-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
-  ).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
-      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: @logs_string_io.string.force_encoding(Encoding::UTF_8),
-    }
-    @result_io.print(JSON.dump(hash)); nil
-  end
-
-  def result_response(result)
-    hash = {
-      result: result,
-      error: nil,
-      log: @logs_string_io.string.force_encoding(Encoding::UTF_8),
-    }
-    @result_io.print(JSON.dump(hash)); nil
-  end
-
-  def error_name(error)
-    error.class.name
-  end
-end

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

@@ -1,15 +0,0 @@
-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

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

data/lib/bosh/cpi/registry_client.rb

@@ -1,106 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

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

data/lib/bosh/cpi.rb

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

data/lib/cloud/config.rb

@@ -1,17 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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)
-      @cpi_path = cpi_path
-      @director_uuid = director_uuid
-      @logger = Config.logger
-    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)
-      request = JSON.dump({
-          'method' => method_name.gsub(/\?$/,''),
-          'arguments' => arguments,
-          'context' => {
-            'director_uuid' => @director_uuid
-          }
-        })
-
-      env = {'PATH' => '/usr/sbin:/usr/bin:/sbin:/bin', 'TMPDIR' => ENV['TMPDIR']}
-      cpi_exec_path = checked_cpi_exec_path
-
-      @logger.debug("External CPI sending request: #{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'])
-      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 handle_error(error_response)
-      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}'"
-      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, error_message
-    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

@@ -1,25 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

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

data/lib/cloud.rb

@@ -1,221 +0,0 @@
-# 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
-
-    private
-
-    def not_implemented(method)
-      raise Bosh::Clouds::NotImplemented,
-            "'#{method}' is not implemented by #{self.class}"
-    end
-
-  end
-end