ibm-cloud-sdk 0.1.6 → 0.1.11

data/lib/ibm/cloud/sdk/vpc/base_collection.rb

@@ -1,108 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module IBM
-  module Cloud
-    module SDK
-      # Container that encapsulates the VPC API.
-      class BaseCollection < BaseVPC
-        # This class is used as a base for collection APIs.
-        # @param parent [Object] The parent instance in the API chain.
-        # @param endpoint [string] A path from the parent to the desired endpoint. In most cases is should be 1 word.
-        # @param array_key [string] The key that the API response holds the endpoint data. When nil the endpoint will be used.
-        # @param child_class [Object] The Object to be used when instanciating the single instance for this class.
-        def initialize(parent, endpoint, array_key: nil, child_class: nil)
-          # Setup empty base instance variables.
-          @params = nil
-
-          array_key ||= endpoint
-
-          # Set the array key and child class.
-          @array_key ||= array_key
-          @instance ||= child_class
-
-          super(parent, endpoint)
-        end
-
-        # A chainable method to set query filters on the collection.
-        # @example vpc.images.params(limit: 1).all
-        #
-        # @param start [String] A server-supplied token determining what resource to start the page on.
-        # @param limit [Integer] The number of resources to return on a page  allowed values are between 1 and 100
-        # @param resource_group [String] Filters the collection to resources within one of the resource groups identified in a comma-separated list of resource group identifiers
-        # @return [BaseCollection] This class with the param instance variable set.
-        def params(start: nil, limit: nil, resource_group: nil)
-          @params = {}
-          @params[:start] = start if start
-          @params[:limit] = limit if limit
-          @params[:resource_group] = resource_group if resource_group
-          self
-        end
-
-        # Retrieve the collection from the cloud.
-        # @return [IBM::Cloud::SDK::VPC::Response] The http response object.
-        def fetch
-          @data ||= get(params: @params)
-        end
-
-        # Get an iterable for the resource collection.
-        # @return [Enumerator] Use standard each, next idioms.
-        def all
-          each_resource(url)
-        end
-
-        # Fetch all data and return in an array.
-        # @return [Array] Hashes of the returned data.
-        def data
-          all.to_a
-        end
-
-        # Determine if the collection has a total_count key in its response.
-        # @return [Boolean]
-        def has_count?
-          fetch.json&.key?(:total_count)
-        end
-
-        # Get the total count if it exists in the response. Returns nil otherwise.
-        # @return [Integer] The total count reuturned by the server.
-        def count
-          fetch.json&.fetch(:total_count)
-        end
-
-        # A generic post method to create a resource on the collection.
-        # @param payload [Hash] A hash of parameters to send to the server.
-        # @param payload_type [String] One of the following options json, form, or body.
-        # @return [IBM::Cloud::SDK::VPC::Response] The http response object.
-        def create(payload, payload_type = 'json')
-          adhoc(method: 'post', payload_type: payload_type, payload: payload)
-        end
-
-        # Access a specific instance by either id or name depending on API.
-        def instance(id)
-          @instance.new(self, id)
-        end
-
-        private
-
-        # Create a generator that removes the need for pagination.
-        def each_resource(url, &block)
-          return enum_for(:each_resource, url) unless block_given?
-          return unless url
-
-          response = @connection.adhoc('get', url, metadata(@params)).json
-          resources = response.fetch(@array_key.to_sym)
-
-          resources&.each do |value|
-            yield value
-          end
-          return unless response.key?(:next)
-
-          next_url = response.dig(:next, :href)
-          return unless next_url
-
-          each_resource(next_url, &block)
-        end
-      end
-    end
-  end
-end

data/lib/ibm/cloud/sdk/vpc/base_instance.rb

@@ -1,23 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module IBM
-  module Cloud
-    module SDK
-      # Container that encapsulates the VPC API.
-      class BaseInstance < BaseVPC
-        def details
-          get.hash_response
-        end
-
-        def update(payload)
-          patch(payload)
-        end
-
-        def remove
-          delete
-        end
-      end
-    end
-  end
-end

data/lib/ibm/cloud/sdk/vpc/base_vpc.rb

@@ -1,61 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module IBM
-  module Cloud
-    module SDK
-      # Container that encapsulates the VPC API.
-      class BaseVPC
-        def initialize(parent, endpoint = nil)
-          @endpoint = parent.url(endpoint)
-          @connection = parent.connection
-          @logger = parent.logger
-        end
-
-        attr_reader :endpoint, :connection, :logger
-
-        def adhoc(method: 'get', path: nil, params: {}, payload_type: 'json', payload: {})
-          @connection.adhoc(method.to_sym, url(path), metadata(params, payload_type, payload))
-        end
-
-        def get(path: nil, params: {})
-          adhoc(method: 'get', path: path, params: params)
-        end
-
-        def post(payload = {}, path: nil, params: {}, type: 'json')
-          adhoc(method: 'post', path: path, params: params, payload: payload, payload_type: type)
-        end
-
-        def put(payload = {}, path: nil, params: {})
-          adhoc(method: 'put', path: path, params: params, payload: payload)
-        end
-
-        def patch(payload = {},  path: nil, params: {})
-          adhoc(method: 'patch', path: path, params: params, payload: payload)
-        end
-
-        def delete(path: nil, params: {})
-          adhoc(method: 'delete', path: path, params: params)
-        end
-
-        def url(path = nil)
-          return endpoint unless path
-
-          "#{endpoint}/#{path}"
-        end
-
-        private
-
-        def metadata(params = {}, payload_type = 'json', payload = {})
-          params ||= {}
-          pt = {
-            params: { version: '2020-08-01', generation: 2 }.merge(params)
-          }
-
-          pt[payload_type.to_sym] = payload unless payload.empty?
-          pt
-        end
-      end
-    end
-  end
-end

data/lib/ibm/cloud/sdk/vpc/cloud_sdk.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'http'
-require 'ibm/cloud/sdk/vpc/helpers/connection'
-require 'ibm/cloud/sdk/vpc'
-
-module IBM
-    # Holds the SDK pieces.
-    class CloudSDK
-      def initialize(api_key, logger: nil, options: {})
-        @logger = logger
-        @logger ||= Logger.new($stdout, level: :warn)
-
-        @client = HTTP.use(http_options(options))
-        @connection = IBM::Cloud::SDK::VPC::Connection.new(api_key, logger: @logger, client: @client)
-      end
-
-      def http_options(options = {})
-        options.merge(
-          {
-            logging: { logger: @logger },
-            auto_deflate: {}
-          }
-        )
-      end
-
-      attr_reader :logger, :connection
-
-      def vpc(region = 'us-east')
-        IBM::Cloud::SDK::Vpc.new(region, @connection, logger: @logger)
-      end
-    end
-end

data/lib/ibm/cloud/sdk/vpc/helpers/connection.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-require 'http'
-require_relative 'response'
-
-module IBM
-  module Cloud
-    module SDK
-      module VPC
-
-        # Contols tokens.
-        class Connection
-          def initialize(api_key, logger: nil, client: nil)
-            @api_key = api_key
-            @logger = logger
-            @client = client
-            @token = Token.new(api_key, logger: logger, client: client)
-          end
-
-          attr_reader :client
-
-          def adhoc(verb, uri, opts = {})
-            response = @client.auth(@token.authorization_header).request(verb.to_sym, uri, opts)
-            Response.new(response)
-          end
-
-          def authorization_header
-            @token.authorization_header
-          end
-        end
-
-        # Get a token.
-        class Token
-          def initialize(api_key, logger: nil, client: nil)
-            @api_key = api_key
-            @logger = logger
-            @client = client
-            @data = fetch
-          end
-
-          def fetch
-            payload = {
-              form: {
-                grant_type: 'urn:ibm:params:oauth:grant-type:apikey',
-                apikey: @api_key
-              }
-            }
-            response = HTTP.post('https://iam.cloud.ibm.com/identity/token', payload)
-            @data = Response.new(response).json
-          end
-
-          def expired?
-            fetch unless @data
-            @data.fetch(:expiration).to_i <= Time.now.to_i + 600
-          end
-
-          def authorization_header
-            fetch if expired?
-            "#{@data.fetch(:token_type)} #{@data.fetch(:access_token)}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ibm/cloud/sdk/vpc/helpers/response.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-require 'http'
-
-module IBM
-  module Cloud
-    module SDK
-      module VPC
-        # Encapsulate the HTTP response.
-        class Response
-          def initialize(response)
-            @response = response
-          end
-
-          attr_reader :response
-
-          # Return the response in a hash or array.
-          def json
-            JSON.parse(body, symbolize_names: true)
-          rescue StandardError
-            raise "Error while parsing response body. #{response.body}"
-          end
-
-          # Return the raw response string.
-          def body
-            response.body.to_s
-          end
-
-          # Return the response code.
-          def code
-            response.code
-          end
-
-          alias_method :status, :code
-
-          # Return the raw connection object.
-          def connection
-            response.connection
-          end
-
-          # Return the content type of the response.
-          def content_type
-            response.response.mime_type
-          end
-
-          # Return the textual reason.
-          def reason
-            response.reason
-          end
-
-          # Return the sent url as a string.
-          def url
-            response.uri.to_s
-          end
-
-          # Return the sent url as a URI class.
-          def uri
-            response.uri
-          end
-
-          # Verify that the json response is a hash.
-          def hash_response
-            check_object(Hash)
-          end
-
-          # Verify that the json response is an array.
-          def array_response
-            check_object(Array)
-          end
-
-          # Find a subkey within the returned response.
-          def subkey(key)
-            ret = hash_response
-            sym_key = key.to_sym
-            return ret.fetch(sym_key) if ret.key?(sym_key)
-
-            raise "Key #{key} not found in #{ret}."
-          end
-
-          # Check to see if the returned object is the expected object.
-          def check_object(obj)
-            ret = json
-            return ret if ret.instance_of?(obj)
-
-            raise "Expected #{obj} in response for #{url}. The returned object is a #{ret.class}."
-          end
-        end
-      end
-    end
-  end
-end