vsphere-automation-vapi 0.4.2 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3cdf8a0350015d61f54436a0ad2162879a052443153f259c17d47de35886988
-  data.tar.gz: f1a02a09540dbb623f63eb2f824eeabbd9813d2e13571cca7697ee5c803c8f6d
+  metadata.gz: 2c50126d0d0f65c31f019f16e183bd25fb4448cbc538f9af0019592a119e43c8
+  data.tar.gz: 809568e8de0ac8a69c1a186e4fe85c45eacdb3968a3cb43566ff1953145877ab
 SHA512:
-  metadata.gz: 0aa5807cf85348dae93a03c155038ba5429f7939e1c9019dc37854307dc6458f9ecefb65313599f4b8c9de20c82cdb9fc7d7b1cc81478533d97c5635bf0d288f
-  data.tar.gz: 2abbd94bf222d0513f18c954ddc1f791b4708b6a4db78f453bb62e800b0f1e6d7d3dbe10af39212b0c725c93ff2d2371ed2dd25128aaf912ac89325b71756b44
+  metadata.gz: b5a109540d0844144c7af9b8e7b32cf472bcaff30b132bac7cfa1e431753ea66de46f1f47e966d7e8da9bddd7f850e6e46076c89e07a973cd19128851f381b21
+  data.tar.gz: dc17ee1f7e317555d9f7b1bb04671fe8ee3315cb721b8fd6c75278c9389550249758480603be2418081de3ef726335625ca916584a25df6b0293ae6a61003ffd

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License
+
+Copyright 2017-2019 VMware Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/vsphere-automation-vapi/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-vapi/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.
+
+# vapi - vAPI is an extensible API Platform for modelling and delivering APIs/SDKs/CLIs.
+
+
+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-vapi/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.
+
+# vapi - vAPI is an extensible API Platform for modelling and delivering APIs/SDKs/CLIs.
+
+
+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