ibm-cloud-sdk 0.1.3 → 0.1.8

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

@@ -0,0 +1,107 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative('base_mixins/has_child')
+
+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
+
+          (class << self; include ChildMixin; end) if 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, nil)
+        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
+
+        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

@@ -0,0 +1,23 @@
+# 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_mixins/has_child.rb

@@ -0,0 +1,27 @@
+# typed: true
+# frozen_string_literal: true
+
+module IBM
+  module Cloud
+    module SDK
+      # Access a specific instance by either id or name depending on API.
+      module ChildMixin
+        # Get an instance of the collection object.
+        # @param id [String] ID of Name to search on depending on API.
+        # @return [] The instance object.
+        def instance(id)
+          @instance.new(self, id)
+        end
+
+        # Return the first_instance returned from a collection get.
+        def first_instance
+          result = params(limit: 1).all.first
+          return nil unless result
+          return nil unless result.key?(:id)
+
+          instance(result.fetch(:id))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# 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

@@ -0,0 +1,33 @@
+# 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/exceptions.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module IBM
+  module Cloud
+    module SDK
+      module VPC
+        # Module to contain all custom exception classes.
+        module Exceptions
+          # An exception for http with a response attribute.
+          # @param response [IBM::Cloud::SDK::VPC::Response] The original response object.
+          # @param msg [String] A human readable message.
+          class ExceptionWithResponse < RuntimeError
+            def initialize(response, msg)
+              @response = response
+              super(msg)
+            end
+            # @return [IBM::Cloud::SDK::VPC::Response] The response
+            attr_reader :response
+          end
+
+          # An exception for http status errors with a response attribute.
+          # @param response [IBM::Cloud::SDK::VPC::Response] The original response object.
+          class HttpStatusError < ExceptionWithResponse
+            def initialize(response)
+              msg = "Invalid status #{response.code} for url \"#{response.url}\", #{response.reason}. #{response.body}"
+              super(response, msg)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# typed: false
+# frozen_string_literal: true
+
+module IBM
+  module Cloud
+    module SDK
+      module VPC
+        # Class that deals with groups of floating IPs.
+        class FloatingIPs < BaseCollection
+          def initialize(parent)
+            super(parent, 'floating_ips', child_class: FloatingIP)
+          end
+        end
+
+        # Class that deals with a single floating IP.
+        class FloatingIP < BaseInstance; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+module IBM
+  module Cloud
+    module SDK
+      module VPC
+        # A list of subnets
+        class FlowLogCollectors < BaseCollection
+          def initialize(parent)
+            super(parent, 'flow_log_collectors', child_class: FlowLogCollectors)
+          end
+        end
+
+        # A single subnet
+        class FlowLogCollector < BaseInstance; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'http'
+require_relative 'response'
+
+module IBM
+  module Cloud
+    module SDK
+      module VPC
+        # The Connection object to be used for all HTTP requests.
+        # @param api_key [String] The API Key to be used for this account.
+        # @param logger [Logger] An instantiated logger instance.
+        # @param client [HTTP::Client] An instantiated HTTP client.
+        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
+
+          # Send a HTTP request. Checks the validity of the response.
+          # @param verb [String] THe HTTP verb to use for this request.
+          # @param uri [String] The Full URL to send.
+          # @option opts [Hash] :params Parameters for URL encoding parameters.
+          # @option opts [Hash] :json Used when sending a hash as application/json content type.
+          # @option opts [Hash] :form Used when sending a hash as a form.
+          # @option opts [Hash] :headers Used to modify headers for request.
+          # @return [IBM::Cloud::SDK::VPC::Response] Wrapped response to query.
+          # @raise [IBM::Cloud::SDK::VPC::Exceptions::HttpStatusError] Response code is not either in 200-series or 404.
+          def adhoc(verb, uri, opts = {})
+            unverified_request(verb, uri, opts).raise_for_status?
+          end
+
+          # Send a HTTP request. Don't do any validation checks.
+          # @see :adhoc for options.
+          def unverified_request(verb, uri, opts = {})
+            response = @client.auth(@token.authorization_header).request(verb.to_s.downcase.to_sym, uri, opts)
+            Response.new(response)
+          end
+
+          # Get bearer token string for clients not using the adhoc method.
+          def authorization_header
+            @token.authorization_header
+          end
+        end
+
+        # The IAM token manager.
+        # @param api_key [String] The API Key to be used for this account.
+        # @param logger [Logger] An instantiated logger instance.
+        # @param client [HTTP::Client] An instantiated HTTP client.
+        class Token
+          def initialize(api_key, logger: nil, client: nil)
+            @api_key = api_key
+            @logger = logger
+            @client = client
+            @data = fetch
+          end
+
+          # Retrieve a new access_token from IAM.
+          # @return [IBM::Cloud::SDK::VPC::Response] Wrapped response to query.
+          # @raise [IBM::Cloud::SDK::VPC::Exceptions::HttpStatusError] Response code is not either in 200-series or 404.
+          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).raise_for_status?.json
+          end
+
+          # Check to see if the access_token is expired. Fetch a new token if none exists.
+          # @return [IBM::Cloud::SDK::VPC::Response] Wrapped response to query.
+          # @raise [IBM::Cloud::SDK::VPC::Exceptions::HttpStatusError] Response code is not either in 200-series or 404.
+          def expired?
+            fetch unless @data
+            @data.fetch(:expiration).to_i <= Time.now.to_i + 600
+          end
+
+          # Get a Bearer token string. Before returning check to see if token is expired.
+          # @return [String] The Bearer token header used in subsequent requests.
+          # @raise [IBM::Cloud::SDK::VPC::Exceptions::HttpStatusError] Response code is not either in 200-series or 404.
+          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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'http'
+
+module IBM
+  module Cloud
+    module SDK
+      module VPC
+        # Encapsulate the HTTP response.
+        # @param response [HTTP::Response] The HTTP response object.
+        class Response
+          def initialize(response)
+            @response = response
+          end
+
+          # The raw HTTP response.
+          # @return [HTTP::Response]
+          attr_reader :response
+
+          # Return the response in a hash or array.
+          # @return [Hash] When response is a hash.
+          # @return [Array] When response is an array.
+          # @raise [Exceptions::ExceptionWithResponse] Contents of body is not properly formatted json.
+          def json
+            JSON.parse(body, symbolize_names: true)
+          rescue StandardError
+            raise Exceptions::ExceptionWithResponse.new(self, "#{url} Error while parsing response body. #{response.body}")
+          end
+
+          # Return the raw response string.
+          # @return [String]
+          # @return [nil] Response does not have body method.
+          def body
+            response&.body.to_s
+          end
+
+          # Return the response code.
+          # @return [Integer] Response has code method.
+          # @return [nil] Response does not have code method.
+          def code
+            response&.code
+          end
+
+          alias status code
+
+          # Return the raw connection object.
+          # @return [HTTP::Connection]
+          # @return [nil] Response does not have a connection method.
+          def connection
+            response&.connection
+          end
+
+          # Chainable method to verify the status code. Raise an exception for non 200-series or 404 status codes.
+          # @return [Response] Allows for method to be chainable.
+          # @raise [Exceptions::HttpStatusError] Raise if status checks failed.
+          def raise_for_status?
+            return self if (200..299).include?(code)
+            return self if code == 404
+
+            raise Exceptions::HttpStatusError.new(self)
+          end
+
+          # Return the content type of the response.
+          # @return [String] The mimetype of the response.
+          # @return [nil] Response does not have response method that responds to mime_type.
+          def content_type
+            response&.response&.mime_type
+          end
+
+          # Return the textual reason.
+          # @return [String] HTTP Reason
+          # @return [nil] Response does not have reaspn method that responds.
+          def reason
+            response&.reason
+          end
+
+          # Return the sent url as a string.
+          # @return [String] Full URL sent
+          # @return [nil] Response does not have response method that responds to mime_type.
+          def url
+            response&.uri.to_s
+          end
+
+          # Return the sent url as a URI class.
+          # @see https://github.com/httprb/http/blob/master/lib/http/uri.rb URI Class doc.
+          # @return [HTTP::URI]
+          # @return [nil] Response does not have response method that responds to mime_type.
+          def uri
+            response&.uri
+          end
+
+          # Verify that the json response is a hash.
+          # @return [Hash] Response from JSON
+          # @raise [RuntimeError] JSON object is not a Hash.
+          def hash_response
+            check_object(Hash)
+          end
+
+          # Verify that the json response is an array.
+          # @return [Array] Response from JSON
+          # @raise [RuntimeError] JSON object is not a Array.
+          def array_response
+            check_object(Array)
+          end
+
+          # Find a subkey within the returned response.
+          # @param key [String] Name of a first level key.
+          # @return [Any] Response from JSON
+          # @raise [RuntimeError] JSON object is not a Array.
+          def subkey(key)
+            ret = hash_response
+            sym_key = key.to_sym
+            return ret.fetch(sym_key) if ret.key?(sym_key)
+
+            msg = "Key #{key} not found in #{ret}."
+            raise Exceptions::ExceptionWithResponse.new(self, msg)
+          end
+
+          # Check to see if the returned object is the expected object.
+          # @param obj [Object] The object to test the response against.
+          # @raise [Exceptions::ExceptionWithResponse] Parsed JSON is not the expecte class.
+          def check_object(obj)
+            ret = json
+            return ret if ret.instance_of?(obj)
+
+            msg = "Expected #{obj} in response for #{url}. The returned object is a #{ret.class}."
+            raise Exceptions::ExceptionWithResponse.new(self, msg)
+          end
+        end
+      end
+    end
+  end
+end