bosh_cpi_networking 2.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 80456c92fa86f1e403aa2c5c9db8da44b91cb51b
+  data.tar.gz: 31d96dfaae8ba996c5878e405d0c0445cbc19dfb
+SHA512:
+  metadata.gz: 3905e313c73b7ed04f3b1974562b5e0b1200433da41315b2759c8ab1ae8cf6c0cb3d003c3612659da560b28b5563542041e978ac4cb1d95e00aa2fb117c95a2a
+  data.tar.gz: a4fa23dece8e65f1f062cd82f92cc5f56dc7932ffd40e3f7638a7ba3289ca9b0ce0c756c56bd5983d375292ff1e6a52865c0f7d0f818e86653fd9b036b2d55db

data/lib/bosh/cpi.rb

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

data/lib/bosh/cpi/cli.rb

@@ -0,0 +1,147 @@
+require 'json'
+
+class Bosh::Cpi::Cli
+  KNOWN_RPC_METHODS = %w(
+    info
+    current_vm_id
+    create_stemcell
+    delete_stemcell
+    create_vm
+    delete_vm
+    has_vm
+    reboot_vm
+    set_vm_metadata
+    set_disk_metadata
+    create_disk
+    has_disk
+    delete_disk
+    attach_disk
+    detach_disk
+    snapshot_disk
+    delete_snapshot
+    get_disks
+    resize_disk
+    ping
+    calculate_vm_cloud_properties
+    create_subnet
+    delete_subnet
+    has_subnet
+    set_subnet_metadata
+  ).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
+    @logger = Bosh::Cpi::Logger.new(STDERR)
+  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(Bosh::Clouds::NotImplemented.name, "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", 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", false)
+    end
+
+    req_id = context['request_id']
+    @logger.set_request_id(req_id)
+
+    configure_director(context['director_uuid'])
+
+    ruby_method = RPC_METHOD_TO_RUBY_METHOD[method] || method
+
+    begin
+      start_time = Time.now.utc
+      @logger.info("Starting #{method}...")
+
+      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)
+    ensure
+      end_time = Time.now.utc
+      @logger.info("Finished #{method} in #{(end_time - start_time).round(2)} seconds")
+    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.rb

@@ -0,0 +1,5 @@
+require 'bosh/cpi'
+
+module Bosh::Cpi
+  module CompatibilityHelpers; 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/logger.rb

@@ -0,0 +1,15 @@
+require 'logger'
+
+class Bosh::Cpi::Logger < Logger
+
+  def initialize(log_device)
+    super(log_device)
+  end
+
+  def set_request_id(req_id)
+    original_formatter = Logger::Formatter.new
+    self.formatter = proc { |severity, datetime, progname, msg|
+      original_formatter.call(severity, datetime, "[req_id #{req_id}]#{progname}", msg)
+    }
+  end
+end

data/lib/bosh/cpi/redactor.rb

@@ -0,0 +1,32 @@
+module Bosh::Cpi
+  class Redactor
+
+    REDACTED = '<redacted>'
+
+    def self.clone_and_redact(hash, *paths)
+      begin
+        hash = JSON.parse(hash.to_json)
+      rescue
+        return nil
+      end
+
+      redact!(hash, *paths)
+    end
+
+    def self.redact!(hash, *json_paths)
+      json_paths.each do |json_path|
+        properties = json_path.split('.')
+        property_to_redact = properties.pop
+
+        target_hash = properties.reduce(hash, &fetch_property)
+        target_hash[property_to_redact] = REDACTED if target_hash.has_key? property_to_redact
+      end
+
+      hash
+    end
+
+    def self.fetch_property
+      -> (hash, property) { hash.fetch(property, {})}
+    end
+  end
+end

data/lib/bosh/cpi/registry_client.rb

@@ -0,0 +1,107 @@
+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"
+      put_headers = @headers.merge('Content-Type' => 'application/json')
+
+      response = @client.put(url, {:body => payload, :header => put_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.rb

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

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/cloud.rb

@@ -0,0 +1,259 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh; module Clouds; end; end
+
+require "forwardable"
+
+require "cloud/config"
+require "cloud/errors"
+
+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
+
+    ## Information about cpi
+    #
+    # Sample info response:
+    #  {"stemcell_formats" =>
+    #    ["aws-raw", "aws-light"]
+    #  }
+    #  @return [Hash] information about cpi, currently stemcell formats, which are supported
+    def info
+      not_implemented(:info)
+    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
+
+    ##
+    # Set metadata for a disk
+    #
+    # Optional. Implement to provide more information for the IaaS.
+    #
+    # @param [String] disk_id disk id that was once returned by {#create_disk}
+    # @param [Hash] metadata metadata key/value pairs
+    # @return [void]
+    def set_disk_metadata(disk_id, metadata)
+      not_implemented(:set_disk_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
+
+    ##
+    # Resizes an existing disk
+    #
+    # @param [String] disk_id disk id
+    # @param [Integer] new_size disk size in MiB
+    # @return [void]
+    def resize_disk(disk_id, new_size)
+      not_implemented(:resize_disk)
+    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

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/version.rb

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

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: bosh_cpi_networking
+version: !ruby/object:Gem::Version
+  version: '2.5'
+platform: ruby
+authors:
+- VMware
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: membrane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.8.3
+description: BOSH CPI with network management support
+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/logger.rb
+- lib/bosh/cpi/redactor.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/version.rb
+homepage: https://github.com/medvedzver/bosh-cpi-ruby
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: BOSH CPI with network management support
+test_files: []