xapixctl 1.0.0 → 1.2.1

data/lib/xapixctl/phoenix_client.rb

@@ -1,163 +1,79 @@
 # frozen_string_literal: true
 
+require 'json'
+require 'psych'
+require 'rest_client'
+require 'xapixctl/phoenix_client/result_handler'
+require 'xapixctl/phoenix_client/organization_connection'
+require 'xapixctl/phoenix_client/project_connection'
+require 'xapixctl/phoenix_client/connection'
+
 module Xapixctl
   module PhoenixClient
-
-    class ResultHandler
-      def initialize(default_success_handler:, default_error_handler:)
-        @success_handler = default_success_handler
-        @error_handler = default_error_handler
-        @result_handler = nil
-        yield self if block_given?
-      end
-
-      def on_success(&block); @success_handler = block; self; end
-
-      def on_error(&block); @error_handler = block; self; end
-
-      def prepare_data(proc); @result_handler = proc; self; end
-
-      def formatter(proc); @formatter = proc; self; end
-
-      def run
-        res = yield
-        res = res.present? ? JSON.parse(res) : res
-        res = @result_handler ? @result_handler.call(res) : res
-        res = @formatter ? @formatter.call(res) : res
-        @success_handler.call(res)
-      rescue RestClient::Exception => err
-        response = JSON.parse(err.response) rescue {}
-        @error_handler.call(err, response)
-      rescue SocketError, Errno::ECONNREFUSED => err
-        @error_handler.call(err, nil)
-      end
-    end
+    # sorting is intentional to reflect dependencies when exporting
+    SUPPORTED_RESOURCE_TYPES = %w[
+      Project
+      Ambassador
+      AuthScheme
+      Credential
+      Proxy
+      CacheConnection
+      Schema
+      DataSource
+      Pipeline
+      Service
+      ServiceInstall
+      EndpointGroup
+      Endpoint
+      StreamGroup
+      Stream
+      StreamProcessor
+      Scheduler
+      ApiPublishing
+      ApiPublishingRole
+    ].freeze
 
     TEXT_FORMATTERS = {
-      all: ->(data) { "id  : %{id}\nkind: %{kind}\nname: %{name}\n\n" % { id: data.dig('metadata', 'id'), kind: data.dig('kind'), name: data.dig('definition', 'name') } }
+      all: ->(data) { "id  : %<id>s\nkind: %<kind>s\nname: %<name>s\n\n" % { id: data.dig('metadata', 'id'), kind: data['kind'], name: data.dig('definition', 'name') } }
     }.freeze
 
     FORMATTERS = {
       json: ->(data) { JSON.pretty_generate(data) },
-      yaml: ->(data) { Psych.dump(data.deep_transform_keys! { |k| k.to_s.camelize(:lower) }) },
+      yaml: ->(data) { Psych.dump(data) },
       text: ->(data) { (TEXT_FORMATTERS[data.dig('metadata', 'type')] || TEXT_FORMATTERS[:all]).call(data) }
     }.freeze
 
-    class Connection
-      DEFAULT_SUCCESS_HANDLER = ->(result) { result }
-      DEFAULT_ERROR_HANDLER = ->(err, _response) { warn "Could not get data: #{err}" }
-
-      # sorting is intentional to reflect dependencies when exporting
-      SUPPORTED_RESOURCE_TYPES = %w[
-        Project
-        Ambassador
-        AuthScheme
-        Credential
-        Proxy
-        CacheConnection
-        Schema
-        DataSource
-        Pipeline
-        EndpointGroup
-        Endpoint
-        StreamGroup
-        Stream
-        ApiPublishing
-        ApiPublishingRole
-      ].freeze
-
-      def initialize(url, token)
-        @client = RestClient::Resource.new(File.join(url, 'api/v1'), verify_ssl: false, accept: :json, content_type: :json, headers: { Authorization: "Bearer #{token}" })
-        @default_success_handler = DEFAULT_SUCCESS_HANDLER
-        @default_error_handler = DEFAULT_ERROR_HANDLER
-      end
-
-      def on_success(&block); @default_success_handler = block; self; end
-
-      def on_error(&block); @default_error_handler = block; self; end
-
-      def resource(resource_type, resource_id, org:, project: nil, format: :hash, &block)
-        result_handler(block).
-          formatter(FORMATTERS[format]).
-          run { @client[resource_path(org, project, resource_type, resource_id)].get }
-      end
-
-      def resource_ids(resource_type, org:, project: nil, &block)
-        result_handler(block).
-          prepare_data(->(data) { data['resource_ids'] }).
-          run { @client[resources_path(org, project, resource_type)].get }
-      end
-
-      def apply(resource_description, org:, project: nil, &block)
-        result_handler(block).
-          run { @client[generic_resource_path(org, project)].put(resource_description.to_json) }
-      end
-
-      def delete(resource_type, resource_id, org:, project: nil, &block)
-        result_handler(block).
-          run { @client[resource_path(org, project, resource_type, resource_id)].delete }
-      end
-
-      def publish(org:, project:, &block)
-        result_handler(block).
-          run { @client[project_publications_path(org, project)].post('') }
-      end
-
-      def logs(correlation_id, org:, project:, &block)
-        result_handler(block).
-          run { @client[project_logss_path(org, project, correlation_id)].get }
-      end
-
-      def available_resource_types(&block)
-        result_handler(block).
-          prepare_data(->(data) { data['resource_types'] }).
-          run { @client[resource_types_path].get }
-      end
-
-      def resource_types_for_export
-        @resource_types_for_export ||=
-          available_resource_types do |res|
-            res.on_success { |available_types| SUPPORTED_RESOURCE_TYPES & available_types.map { |desc| desc['type'] } }
-            res.on_error { |err, _response| raise err }
+    PREVIEW_FORMATTERS = {
+      json: ->(data) { JSON.pretty_generate(data) },
+      yaml: ->(data) { Psych.dump(data) },
+      text: ->(data) do
+        preview = data['preview']
+        if ['RestJson', 'SoapXml'].include?(data['content_type'])
+          res = StringIO.new
+          if preview.is_a?(Hash)
+            res.puts "HTTP #{preview['status']}"
+            preview['headers']&.each { |h, v| res.puts "#{h}: #{v}" }
+            res.puts
+            res.puts preview['body']
+          else
+            res.puts preview
           end
+          res.string
+        else
+          Psych.dump(preview)
+        end
       end
+    }.freeze
 
-      private
-
-      def result_handler(block)
-        ResultHandler.new(default_success_handler: @default_success_handler, default_error_handler: @default_error_handler, &block)
-      end
-
-      def resource_path(org, project, type, id)
-        type = translate_type(type)
-        project ? "/projects/#{org}/#{project}/#{type}/#{id}" : "/orgs/#{org}/#{type}/#{id}"
-      end
-
-      def resources_path(org, project, type)
-        type = translate_type(type)
-        project ? "/projects/#{org}/#{project}/#{type}" : "/orgs/#{org}/#{type}"
-      end
-
-      def generic_resource_path(org, project)
-        project ? "projects/#{org}/#{project}/resource" : "orgs/#{org}/resource"
-      end
-
-      def project_publications_path(org, project)
-        "/projects/#{org}/#{project}/publications"
-      end
-
-      def project_logss_path(org, project, correlation_id)
-        "/projects/#{org}/#{project}/logs/#{correlation_id}"
-      end
+    DEFAULT_SUCCESS_HANDLER = ->(result) { result }
+    DEFAULT_ERROR_HANDLER = ->(err, _response) { warn "Could not get data: #{err}" }
 
-      def resource_types_path
-        "/resource_types"
-      end
+    def self.connection(url, token, default_success_handler: DEFAULT_SUCCESS_HANDLER, default_error_handler: DEFAULT_ERROR_HANDLER, logging: nil)
+      Connection.new(url, token, default_success_handler, default_error_handler, logging)
+    end
 
-      def translate_type(resource_type)
-        return 'ApiPublishingRole' if resource_type == 'ApiPublishing/Role'
-        resource_type.sub(%r[/.*], '') # cut off everything after first slash
-      end
+    def self.supported_type?(type)
+      SUPPORTED_RESOURCE_TYPES.include?(type)
     end
   end
 end

data/lib/xapixctl/phoenix_client/connection.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Xapixctl
+  module PhoenixClient
+    class Connection
+      DEFAULT_CLIENT_OPTS = { verify_ssl: false, headers: { accept: :json } }.freeze
+
+      attr_reader :xapix_url, :client
+
+      def initialize(url, token, default_success_handler, default_error_handler, logging)
+        @xapix_url = url
+        client_opts = DEFAULT_CLIENT_OPTS.deep_merge(headers: { Authorization: "Bearer #{token}" })
+        client_opts.merge!(log: RestClient.create_log(logging)) if logging
+        @client = RestClient::Resource.new(File.join(url, 'api/v1'), client_opts)
+        @default_success_handler = default_success_handler
+        @default_error_handler = default_error_handler
+      end
+
+      def on_success(&block); @default_success_handler = block; self; end
+
+      def on_error(&block); @default_error_handler = block; self; end
+
+      def available_resource_types(&block)
+        @available_resource_types ||= begin
+          result_handler(block).
+            prepare_data(->(data) { data['resource_types'].freeze }).
+            run { @client[resource_types_path].get }
+        end
+      end
+
+      def organization(org)
+        OrganizationConnection.new(self, org)
+      end
+
+      def project(org:, project:)
+        ProjectConnection.new(self, org, project)
+      end
+
+      def result_handler(block)
+        ResultHandler.new(default_success_handler: @default_success_handler, default_error_handler: @default_error_handler, &block)
+      end
+
+      private
+
+      def resource_types_path
+        "/resource_types"
+      end
+    end
+  end
+end

data/lib/xapixctl/phoenix_client/organization_connection.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Xapixctl
+  module PhoenixClient
+    class OrganizationConnection
+      attr_reader :org
+
+      def initialize(connection, org)
+        @connection = connection
+        @client = connection.client
+        @org = org
+      end
+
+      def resource(resource_type, resource_id, format: :hash, &block)
+        result_handler(block).
+          formatter(FORMATTERS[format]).
+          run { @client[resource_path(resource_type, resource_id)].get }
+      end
+
+      def resource_ids(resource_type, &block)
+        result_handler(block).
+          prepare_data(->(data) { data['resource_ids'] }).
+          run { @client[resources_path(resource_type)].get }
+      end
+
+      def apply(resource_description, &block)
+        result_handler(block).
+          prepare_data(->(data) { data['resource_ids'] }).
+          run { @client[generic_resource_path].put(resource_description.to_json, content_type: :json) }
+      end
+
+      def delete(resource_type, resource_id, &block)
+        result_handler(block).
+          run { @client[resource_path(resource_type, resource_id)].delete }
+      end
+
+      private
+
+      def result_handler(block)
+        @connection.result_handler(block)
+      end
+
+      def resource_path(type, id)
+        "/orgs/#{@org}/#{translate_type(type)}/#{id}"
+      end
+
+      def resources_path(type)
+        "/orgs/#{@org}/#{translate_type(type)}"
+      end
+
+      def generic_resource_path
+        "orgs/#{@org}/resource"
+      end
+
+      def translate_type(resource_type)
+        return 'ApiPublishingRole' if resource_type == 'ApiPublishing/Role'
+        resource_type.sub(%r[/.*], '') # cut off everything after first slash
+      end
+    end
+  end
+end

data/lib/xapixctl/phoenix_client/project_connection.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Xapixctl
+  module PhoenixClient
+    class ProjectConnection < OrganizationConnection
+      attr_reader :project
+
+      def initialize(connection, org, project)
+        super(connection, org)
+        @project = project
+      end
+
+      def project_resource(format: :hash, &block)
+        organization.resource('Project', @project, format: format, &block)
+      end
+
+      def organization
+        OrganizationConnection.new(@connection, @org)
+      end
+
+      def resource_types_for_export
+        @resource_types_for_export ||=
+          @connection.available_resource_types do |res|
+            res.on_success do |available_types|
+              prj_types = available_types.select { |desc| desc['context'] == 'Project' }
+              SUPPORTED_RESOURCE_TYPES & prj_types.map { |desc| desc['type'] }
+            end
+          end
+      end
+
+      # Notes on parameters:
+      # - Query parameters should be part of the URL
+      # - Path parameters should be marked with `{name}` in the URL, and values should be given in path_params hash
+      # - Headers should be given in headers hash
+      # - Cookies should be given in cookies hash
+      # - The body has to be given as a string
+      # - The required authentication schemes should be listed, referring to previously created schemes
+      #
+      # This returns a hash like the following:
+      #   "data_source" => { "id" => id, "resource_description" => resource_description }
+      #
+      # To successfully onboard a DB using the API, the following steps are needed:
+      #  1. setup the data source using add_rest_data_source.
+      #  2. retrieve a preview using preview_data_source using the id returned by previous step
+      #  3. confirm preview
+      #  4. call accept_data_source_preview to complete onboarding
+      #
+      def add_rest_data_source(http_method:, url:, path_params: {}, headers: {}, cookies: {}, body: nil, auth_schemes: [], &block)
+        data_source_details = {
+          data_source: {
+            http_method: http_method, url: url,
+            parameters: { path: path_params.to_query, header: headers.to_query, cookies: cookies.to_query, body: body },
+            auth_schemes: auth_schemes
+          }
+        }
+        result_handler(block).
+          run { @client[rest_data_source_path].post(data_source_details.to_json, content_type: :json) }
+      end
+
+      # Notes on parameters:
+      # - To call a data source which requires authentication, provide a hash with each required auth scheme as key and
+      #   as the value a reference to a previously created credential.
+      #   Example: { scheme_ref1 => credential_ref1, scheme_ref2 => credential_ref2 }
+      #
+      # This returns a hashified preview like the following:
+      #   { "preview" => {
+      #       "sample" => { "status" => integer, "body" => { ... }, "headers" => { ... }, "cookies" => { ... } },
+      #       "fetched_at" => Timestamp },
+      #     "data_source" => { "id" => id, "resource_description" => resource_description } }
+      #
+      def data_source_preview(data_source_id, authentications: {}, &block)
+        preview_data = {
+          authentications: authentications.map { |scheme, cred| { auth_scheme_id: scheme, auth_credential_id: cred } }
+        }
+        result_handler(block).
+          run { @client[data_source_preview_path(data_source_id)].post(preview_data.to_json, content_type: :json) }
+      end
+
+      def pipeline_preview(pipeline_id, format: :hash, &block)
+        result_handler(block).
+          prepare_data(->(data) { data['pipeline_preview'] }).
+          formatter(PREVIEW_FORMATTERS[format]).
+          run { @client[pipeline_preview_path(pipeline_id)].get }
+      end
+
+      def endpoint_preview(endpoint_id, format: :hash, &block)
+        result_handler(block).
+          prepare_data(->(data) { data['endpoint_preview'] }).
+          formatter(PREVIEW_FORMATTERS[format]).
+          run { @client[endpoint_preview_path(endpoint_id)].get }
+      end
+
+      def stream_processor_preview(stream_processor_id, format: :hash, &block)
+        result_handler(block).
+          prepare_data(->(data) { data['stream_processor_preview'] }).
+          formatter(PREVIEW_FORMATTERS[format]).
+          run { @client[stream_processor_preview_path(stream_processor_id)].get }
+      end
+
+      def publish(&block)
+        result_handler(block).
+          run { @client[project_publications_path].post('') }
+      end
+
+      def logs(correlation_id, &block)
+        result_handler(block).
+          run { @client[project_logss_path(correlation_id)].get }
+      end
+
+      # This returns a hashified preview like the following:
+
+      def accept_data_source_preview(data_source_id, &block)
+        result_handler(block).
+          run { @client[data_source_preview_path(data_source_id)].patch('') }
+      end
+
+      def public_project_url
+        File.join(@connection.xapix_url, @org, @project)
+      end
+
+      private
+
+      def rest_data_source_path
+        "/projects/#{@org}/#{@project}/onboarding/data_sources/rest"
+      end
+
+      def data_source_preview_path(id)
+        "/projects/#{@org}/#{@project}/onboarding/data_sources/#{id}/preview"
+      end
+
+      def resource_path(type, id)
+        "/projects/#{@org}/#{@project}/#{translate_type(type)}/#{id}"
+      end
+
+      def resources_path(type)
+        "/projects/#{@org}/#{@project}/#{translate_type(type)}"
+      end
+
+      def generic_resource_path
+        "projects/#{@org}/#{@project}/resource"
+      end
+
+      def pipeline_preview_path(pipeline)
+        "/projects/#{@org}/#{@project}/pipelines/#{pipeline}/preview"
+      end
+
+      def endpoint_preview_path(endpoint)
+        "/projects/#{@org}/#{@project}/endpoints/#{endpoint}/preview"
+      end
+
+      def stream_processor_preview_path(stream_processor)
+        "/projects/#{@org}/#{@project}/stream_processors/#{stream_processor}/preview"
+      end
+
+      def project_publications_path
+        "/projects/#{@org}/#{@project}/publications"
+      end
+
+      def project_logss_path(correlation_id)
+        "/projects/#{@org}/#{@project}/logs/#{correlation_id}"
+      end
+    end
+  end
+end