vsphere-automation-cis 0.4.5 → 0.4.6

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

@@ -1,260 +0,0 @@
-# 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-cis/api_error.rb

@@ -1,34 +0,0 @@
-# Copyright (c) 2018-2019 VMware, Inc.  All Rights Reserved.
-# SPDX-License-Identifier: MIT
-
-# DO NOT MODIFY. THIS CODE IS GENERATED. CHANGES WILL BE OVERWRITTEN.
-
-# cis - No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
-
-
-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-cis/configuration.rb

@@ -1,212 +0,0 @@
-# Copyright (c) 2018-2019 VMware, Inc.  All Rights Reserved.
-# SPDX-License-Identifier: MIT
-
-# DO NOT MODIFY. THIS CODE IS GENERATED. CHANGES WILL BE OVERWRITTEN.
-
-# cis - No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
-
-
-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 = '/rest'
-      @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