vsphere-automation-vcenter 0.4.6 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 994cee99469ce90f130258eefb04196b97ef903a91bf31a75625885181b307b4
-  data.tar.gz: de1514bbb03a1f3c47551ecda38d7f8c7ff2eb0534f64e3d6926560e091ad329
+  metadata.gz: 2c184273a1334c43b9a7dad18b741a743ddd8ee6bb9b4432e3f563562db1d2aa
+  data.tar.gz: dba103c6ba29ef327b86dfa748b68023c04dba56c7b49f729063dcab44383749
 SHA512:
-  metadata.gz: de5a2c2fb0bfe5df6feee2e318ecc12ea0940417fc76cd8693afbd9d273f8368fbfd3e1e940931af12bfa227196c9a0416d1ef9e9825f8a0f8a6cec6ec610181
-  data.tar.gz: 443135d3b5e9fe30a805e58b22e1eb7abb1ca09ad4504a02de0d37e95062139e09a210aa8d93613c6a3e27b7d89b2486ef4dca2b737be8419d5866b9d5ad0a89
+  metadata.gz: 6aaed04413699f5c6b9f76cecc4ac4ac06a3427a01f92e0d6806d947333de359db6406addd9058aa2b49ad24e352bc354f08ba2b7bbd68766ec7e39fb46c70b9
+  data.tar.gz: db2d2a0d7a79ebd820be7af2291d758cb79fcb403a500fcf414699b2ec548b57e20bff3bf1913da8ac64ad9b3026dc29da1f6b385b8bcf20d96dcd50e3669fce

data/lib/vsphere-automation-vcenter/api_client.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'logger'
+require 'net/http'
+require 'openssl'
+require 'uri'
+require 'vsphere-automation-runtime/configuration'
+require 'vsphere-automation-runtime/version'
+
+module VSphereAutomation
+  # The client responsible for communicating with the API.
+  class ApiClient
+    # The Configuration object holding settings to be used in the API client.
+    attr_accessor :config
+
+    # Defines the headers to be used in HTTP requests of all API calls by
+    # default.
+    #
+    # @return [Hash]
+    attr_reader :default_headers
+
+    # Creates a new instance
+    #
+    # @param config [Configuration] configuration object with values to use
+    def initialize(config = Configuration.default)
+      @config = config
+      @http = create_http
+      @user_agent = default_user_agent
+      @default_headers = { 'Content-Type' => 'application/json',
+                           'User-Agent' => @user_agent }
+    end
+
+    # Retrieves an instance of the object in it's default state
+    #
+    # @return [ApiClient] an instance of the object in it's default state
+    def self.default
+      DEFAULT
+    end
+
+    # Build the collection of parameters
+    def build_collection_param(params, format)
+      params
+    end
+
+    # Make a request to an API endpoint with the given options
+    #
+    # @param http_method [Symbol] the HTTP method to be used
+    # @param path [String] the path request will be made to
+    # @param opts [Hash] any additional options needed
+    # @return [Array<(Object, Fixnum, Hash)>] the deserialized body, status
+    #   code, and headers.
+    def call_api(http_method, path, opts = {})
+      query_params = opts.fetch(:query_params, {})
+      header_params = opts.fetch(:header_params, {})
+      form_params = opts.fetch(:form_params, {})
+      add_auth(query_params, header_params, opts.fetch(:auth_names, []))
+
+      uri = build_request_uri(path, query_params)
+      request = Net::HTTP.const_get(http_method.capitalize).new(uri)
+
+      add_form_params(request, form_params)
+      add_header_params(request, header_params)
+      request.body = opts[:body] if opts[:body]
+      request.content_type = request['Content-Type'] if request['Content-Type']
+
+      if @config.debugging
+        @config.logger.debug("Request Body:\n#{request.body}\n")
+      end
+
+      response = @http.request(request)
+      @cookie = cookie_from_response(response)
+      api_key_from_response(response)
+
+      return_type = opts.fetch(:return_type, {}).fetch(response.code, nil)
+      data = deserialize(response, return_type)
+      [data, Integer(response.code), response.each_header.to_h]
+    end
+
+    # Takes an object and returns the object as an HTTP body
+    #
+    # @param object [Object] object to transform
+    # @return [String] object as JSON string
+    def object_to_http_body(object)
+      return object.map { |o| object_to_http_body(o) } if object.is_a?(Array)
+
+      return object unless object.respond_to?(:to_hash)
+
+      object.to_hash.to_json
+    end
+
+    # Select an Accept header to use
+    #
+    # @param types [Array] a list of suggested types
+    # @return [String] the Accept header value
+    def select_header_accept(types)
+      return DEFAULT_MIME_TYPE unless types.is_a?(Array)
+
+      types.find { |t| t.include?('json') } || types.join(', ')
+    end
+
+    # Select an Content-Type header to use
+    #
+    # @param types [Array] a list of suggested types
+    # @return [String] the Content-Type header value
+    def select_header_content_type(types)
+      return DEFAULT_MIME_TYPE unless types.is_a?(Array)
+
+      types.find { |t| t.include?('json') } || types.first
+    end
+
+    private
+
+    def add_auth(query_params, header_params, auth_names)
+      auth_names.map do |name|
+        settings = @config.auth_settings.fetch(name, {})
+        case settings[:in]
+        when 'header'
+          header_params[settings[:key]] = settings[:value]
+          api_key_from_cookie(settings) unless settings[:value]
+        when 'query'
+          query_params[settings[:key]] = settings[:value]
+        end
+      end
+    end
+
+    def add_form_params(request, form_params)
+      request.set_form_data(form_params) unless form_params.empty?
+    end
+
+    def add_header_params(request, headers)
+      header_params = @default_headers.merge(headers)
+      header_params.merge!(Hash(@cookie))
+      header_params.map { |name, value| request[name] = value }
+    end
+
+    def add_query_params(uri, query_params)
+      uri.query = URI.encode_www_form(query_params)
+    end
+
+    def build_request_uri(path = '', query_params = {})
+      path = "/#{path}".gsub(%r{/+}, '/')
+      uri = URI.parse(@config.base_url + path)
+      add_query_params(uri, query_params)
+      forced_query_params = path.split('?')[1]
+      return URI.join(uri, '?' + forced_query_params) if forced_query_params
+
+      uri
+    end
+
+    def create_http
+      uri = build_request_uri
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = @config.scheme == 'https'
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE unless @config.verify_ssl_host
+      http.read_timeout = @config.timeout
+      http
+    end
+
+    # The default user agent
+    #
+    # @return [String] the default user agent
+    def default_user_agent
+      "SDK/#{VSphereAutomation::Runtime::VERSION} "\
+      "Ruby/#{RUBY_VERSION} "\
+      "(#{Gem::Platform.local.os}; "\
+      "#{Gem::Platform.local.version}; "\
+      "#{Gem::Platform.local.cpu})"
+    end
+
+    # Deserialize the response to the given return type
+    #
+    # @param [Response] response the HTTP response
+    # @param [String] return_type the type to return
+    # @return [Object] the response represented as the return type
+    def deserialize(response, return_type)
+      body = response.body
+
+      return nil if body.nil? || body.empty? || return_type.nil?
+
+      begin
+        data = JSON.parse("[#{body}]", symbolize_names: true).first
+      rescue JSON::ParserError => e
+        raise e unless %w[String Date DateTime].include?(return_type)
+
+        data = body
+      end
+
+      convert_to_type(data, return_type)
+    end
+
+    def convert_to_type(data, return_type)
+      return nil if data.nil?
+      case return_type
+      when 'String'
+        data.to_s
+      when 'Integer'
+        data.to_i
+      when 'Float'
+        data.to_f
+      when 'BOOLEAN'
+        data == true
+      when 'DateTime'
+        # parse date time (expecting ISO 8601 format)
+        DateTime.parse data
+      when 'Date'
+        # parse date time (expecting ISO 8601 format)
+        Date.parse data
+      when 'Object'
+        # generic object (usually a Hash), return directly
+        data
+      when /\AArray<(.+)>\z/
+        # e.g. Array<Pet>
+        sub_type = $1
+        data.map { |item| convert_to_type(item, sub_type) }
+      when /\AHash\<String, (.+)\>\z/
+        # e.g. Hash<String, Integer>
+        sub_type = $1
+        {}.tap do |hash|
+          data.each { |k, v| hash[k] = convert_to_type(v, sub_type) }
+        end
+      else
+        # models, e.g. Pet
+        VSphereAutomation.const_get(return_type).new.tap do |model|
+          model.build_from_hash data
+        end
+      end
+    end
+
+    # Create the Cookie header from a response
+    #
+    # @param response [Net::HTTPResponse] the response
+    # @return [Hash, nil] the Cookie header
+    def cookie_from_response(response)
+      { 'Cookie' => response['set-cookie'] } if response['set-cookie']
+    end
+
+    def api_key_from_response(response)
+      key = @config.auth_settings['api_key'][:key]
+      @config.api_key[key] = response[key] if response[key]
+    end
+
+    def api_key_from_cookie(auth)
+      return if @cookie.nil?
+
+      regex = /(?<key>#{auth[:key]})=(?<value>\w+)/
+      matches = Hash(@cookie)['Cookie'].match(regex)
+      key = @config.auth_settings['api_key'][:key]
+      @config.api_key[key] = matches[:value] if matches
+    end
+
+    # An instance of the object in it's default state
+    DEFAULT = new
+
+    # The default MIME type for Content-Type and Accept headers
+    DEFAULT_MIME_TYPE = 'application/json'
+
+    private_constant :DEFAULT, :DEFAULT_MIME_TYPE
+  end
+end

data/lib/vsphere-automation-vcenter/api_error.rb

@@ -0,0 +1,34 @@
+# Copyright (c) 2018-2019 VMware, Inc.  All Rights Reserved.
+# SPDX-License-Identifier: MIT
+
+# DO NOT MODIFY. THIS CODE IS GENERATED. CHANGES WILL BE OVERWRITTEN.
+
+# vcenter - VMware vCenter Server provides a centralized platform for managing your VMware vSphere environments
+
+
+module VSphereAutomation
+  class ApiError < StandardError
+    attr_reader :code, :response_headers, :response_body
+
+    # Usage examples:
+    #   ApiError.new
+    #   ApiError.new("message")
+    #   ApiError.new(:code => 500, :response_headers => {}, :response_body => "")
+    #   ApiError.new(:code => 404, :message => "Not Found")
+    def initialize(arg = nil)
+      if arg.is_a? Hash
+        if arg.key?(:message) || arg.key?('message')
+          super(arg[:message] || arg['message'])
+        else
+          super arg
+        end
+
+        arg.each do |k, v|
+          instance_variable_set "@#{k}", v
+        end
+      else
+        super arg
+      end
+    end
+  end
+end

data/lib/vsphere-automation-vcenter/configuration.rb

@@ -0,0 +1,212 @@
+# Copyright (c) 2018-2019 VMware, Inc.  All Rights Reserved.
+# SPDX-License-Identifier: MIT
+
+# DO NOT MODIFY. THIS CODE IS GENERATED. CHANGES WILL BE OVERWRITTEN.
+
+# vcenter - VMware vCenter Server provides a centralized platform for managing your VMware vSphere environments
+
+
+require 'uri'
+
+module VSphereAutomation
+  class Configuration
+    # Defines url scheme
+    attr_accessor :scheme
+
+    # Defines url host
+    attr_accessor :host
+
+    # Defines url base path
+    attr_accessor :base_path
+
+    # Defines API keys used with API Key authentications.
+    #
+    # @return [Hash] key: parameter name, value: parameter value (API key)
+    #
+    # @example parameter name is "api_key", API key is "xxx" (e.g. "api_key=xxx" in query string)
+    #   config.api_key['api_key'] = 'xxx'
+    attr_accessor :api_key
+
+    # Defines API key prefixes used with API Key authentications.
+    #
+    # @return [Hash] key: parameter name, value: API key prefix
+    #
+    # @example parameter name is "Authorization", API key prefix is "Token" (e.g. "Authorization: Token xxx" in headers)
+    #   config.api_key_prefix['api_key'] = 'Token'
+    attr_accessor :api_key_prefix
+
+    # Defines the username used with HTTP basic authentication.
+    #
+    # @return [String]
+    attr_accessor :username
+
+    # Defines the password used with HTTP basic authentication.
+    #
+    # @return [String]
+    attr_accessor :password
+
+    # Defines the access token (Bearer) used with OAuth2.
+    attr_accessor :access_token
+
+    # Set this to enable/disable debugging. When enabled (set to true), HTTP request/response
+    # details will be logged with `logger.debug` (see the `logger` attribute).
+    # Default to false.
+    #
+    # @return [true, false]
+    attr_accessor :debugging
+
+    # Defines the logger used for debugging.
+    # Default to `Rails.logger` (when in Rails) or logging to STDOUT.
+    #
+    # @return [#debug]
+    attr_accessor :logger
+
+    # Defines the temporary folder to store downloaded files
+    # (for API endpoints that have file response).
+    # Default to use `Tempfile`.
+    #
+    # @return [String]
+    attr_accessor :temp_folder_path
+
+    # The time limit for HTTP request in seconds.
+    # Default to 0 (never times out).
+    attr_accessor :timeout
+
+    # Set this to false to skip client side validation in the operation.
+    # Default to true.
+    # @return [true, false]
+    attr_accessor :client_side_validation
+
+    ### TLS/SSL setting
+    # Set this to false to skip verifying SSL certificate when calling API from https server.
+    # Default to true.
+    #
+    # @note Do NOT set it to false in production code, otherwise you would face multiple types of cryptographic attacks.
+    #
+    # @return [true, false]
+    attr_accessor :verify_ssl
+
+    ### TLS/SSL setting
+    # Set this to false to skip verifying SSL host name
+    # Default to true.
+    #
+    # @note Do NOT set it to false in production code, otherwise you would face multiple types of cryptographic attacks.
+    #
+    # @return [true, false]
+    attr_accessor :verify_ssl_host
+
+    ### TLS/SSL setting
+    # Set this to customize the certificate file to verify the peer.
+    #
+    # @return [String] the path to the certificate file
+    #
+    # @see The `cainfo` option of Typhoeus, `--cert` option of libcurl. Related source code:
+    # https://github.com/typhoeus/typhoeus/blob/master/lib/typhoeus/easy_factory.rb#L145
+    attr_accessor :ssl_ca_cert
+
+    ### TLS/SSL setting
+    # Client certificate file (for client certificate)
+    attr_accessor :cert_file
+
+    ### TLS/SSL setting
+    # Client private key file (for client certificate)
+    attr_accessor :key_file
+
+    # Set this to customize parameters encoding of array parameter with multi collectionFormat.
+    # Default to nil.
+    #
+    # @see The params_encoding option of Ethon. Related source code:
+    # https://github.com/typhoeus/ethon/blob/master/lib/ethon/easy/queryable.rb#L96
+    attr_accessor :params_encoding
+
+    attr_accessor :inject_format
+
+    attr_accessor :force_ending_format
+
+    def initialize
+      @scheme = 'https'
+      @host = '<vcenter>'
+      @base_path = ''
+      @api_key = {}
+      @api_key_prefix = {}
+      @timeout = nil
+      @client_side_validation = true
+      @verify_ssl = true
+      @verify_ssl_host = true
+      @params_encoding = :multi
+      @cert_file = nil
+      @key_file = nil
+      @debugging = false
+      @inject_format = false
+      @force_ending_format = false
+      @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+
+      yield(self) if block_given?
+    end
+
+    # The default Configuration object.
+    def self.default
+      @@default ||= Configuration.new
+    end
+
+    def configure
+      yield(self) if block_given?
+    end
+
+    def scheme=(scheme)
+      # remove :// from scheme
+      @scheme = scheme.sub(/:\/\//, '')
+    end
+
+    def host=(host)
+      # remove http(s):// and anything after a slash
+      @host = host.sub(/https?:\/\//, '').split('/').first
+    end
+
+    def base_path=(base_path)
+      # Add leading and trailing slashes to base_path
+      @base_path = "/#{base_path}".gsub(/\/+/, '/')
+      @base_path = '' if @base_path == '/'
+    end
+
+    def base_url
+      url = "#{scheme}://#{[host, base_path].join('/').gsub(/\/+/, '/')}".sub(/\/+\z/, '')
+      URI.encode(url)
+    end
+
+    # Gets API key (with prefix if set).
+    # @param [String] param_name the parameter name of API key auth
+    def api_key_with_prefix(param_name)
+      if @api_key_prefix[param_name]
+        "#{@api_key_prefix[param_name]} #{@api_key[param_name]}"
+      else
+        @api_key[param_name]
+      end
+    end
+
+    # Gets Basic Auth token string
+    def basic_auth_token
+      'Basic ' + ["#{username}:#{password}"].pack('m').delete("\r\n")
+    end
+
+    # Returns Auth Settings hash for api client.
+    def auth_settings
+      {
+        'api_key' =>
+          {
+            type: 'api_key',
+            in: 'header',
+            key: 'vmware-api-session-id',
+            value: api_key_with_prefix('vmware-api-session-id')
+          },
+        'basic_auth' =>
+          {
+            type: 'basic',
+            in: 'header',
+            key: 'Authorization',
+            value: basic_auth_token
+          },
+      }
+    end
+  end
+end

data/lib/vsphere-automation-vcenter/version.rb

@@ -8,6 +8,6 @@
 
 module VSphereAutomation
   module VCenter
-    VERSION = '0.4.6'
+    VERSION = '0.4.7'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vsphere-automation-vcenter
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.4.7
 platform: ruby
 authors:
 - J.R. Garcia
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-29 00:00:00.000000000 Z
+date: 2020-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: vsphere-automation-runtime
@@ -211,6 +211,9 @@ files:
 - lib/vsphere-automation-vcenter/api/vm_storage_policy_api.rb
 - lib/vsphere-automation-vcenter/api/vm_storage_policy_compliance_api.rb
 - lib/vsphere-automation-vcenter/api/vm_template_library_items_api.rb
+- lib/vsphere-automation-vcenter/api_client.rb
+- lib/vsphere-automation-vcenter/api_error.rb
+- lib/vsphere-automation-vcenter/configuration.rb
 - lib/vsphere-automation-vcenter/models/cis_task_progress.rb
 - lib/vsphere-automation-vcenter/models/cis_task_status.rb
 - lib/vsphere-automation-vcenter/models/vapi_std_dynamic_id.rb
@@ -751,7 +754,7 @@ homepage: https://github.com/vmware/vsphere-automation-sdk-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -766,8 +769,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: A Ruby SDK for the vSphere APIs (vCenter)
 test_files: []