operaton-bpm-client 0.1.0

data/lib/operaton/bpm/client/impl/request_dto.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Operaton
+  module Bpm
+    module Client
+      module Impl
+        # Mirrors org.operaton.bpm.client.impl.RequestDto
+        class RequestDto
+          attr_reader :worker_id
+
+          def initialize(worker_id)
+            @worker_id = worker_id
+          end
+
+          # Subclasses add their fields; nil values are omitted from the JSON
+          # payload (Jackson NON_NULL semantics where the Java DTO uses them).
+          def as_json
+            { "workerId" => worker_id }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/impl/request_executor.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "openssl"
+require "timeout"
+
+require_relative "external_task_client_logger"
+require_relative "engine_client_logger"
+require_relative "engine_client_exception"
+require_relative "engine_rest_exception_dto"
+require_relative "object_mapper"
+
+module Operaton
+  module Bpm
+    module Client
+      module Impl
+        # Mirrors org.operaton.bpm.client.impl.RequestExecutor, built on
+        # Net::HTTP instead of Apache HttpClient.
+        class RequestExecutor
+          HEADER_CONTENT_TYPE_JSON = ["Content-Type", "application/json"].freeze
+          HEADER_USER_AGENT = ["User-Agent", "Operaton External Task Client"].freeze
+
+          # Sentinels standing in for the Java response-class parameters
+          VOID = :void
+          BYTES = :bytes
+
+          def initialize(object_mapper, interceptor_handler: nil, http_customizer: nil, read_timeout: 60)
+            @object_mapper = object_mapper
+            @interceptor_handler = interceptor_handler
+            @http_customizer = http_customizer
+            @read_timeout = read_timeout
+            @logger = ExternalTaskClientLogger.engine_client_logger
+          end
+
+          # response_type: VOID, BYTES, or a class/array responding to .from_json.
+          # Passing [SomeDto] deserializes a JSON array into a list of DTOs.
+          def post_request(resource_url, request_dto, response_type)
+            body = serialize_request(request_dto)
+            uri = URI(resource_url)
+
+            request = Net::HTTP::Post.new(uri)
+            request[HEADER_USER_AGENT[0]] = HEADER_USER_AGENT[1]
+            request[HEADER_CONTENT_TYPE_JSON[0]] = HEADER_CONTENT_TYPE_JSON[1]
+            request.body = body
+
+            execute_request(uri, request, response_type)
+          end
+
+          def get_request(resource_url)
+            uri = URI(resource_url)
+
+            request = Net::HTTP::Get.new(uri)
+            request[HEADER_USER_AGENT[0]] = HEADER_USER_AGENT[1]
+            request[HEADER_CONTENT_TYPE_JSON[0]] = HEADER_CONTENT_TYPE_JSON[1]
+
+            execute_request(uri, request, BYTES)
+          end
+
+          protected
+
+          def execute_request(uri, request, response_type)
+            @interceptor_handler&.process(request)
+
+            response = perform_http_request(uri, request)
+            handle_response(request, response, response_type)
+          rescue RestException => e
+            raise @logger.exception_while_receiving_response(describe(request), e)
+          rescue IOError, SystemCallError, SocketError, Timeout::Error,
+                 OpenSSL::SSL::SSLError, Net::OpenTimeout, Net::ReadTimeout => e
+            raise @logger.exception_while_establishing_connection(describe(request), e)
+          end
+
+          def perform_http_request(uri, request)
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = uri.scheme == "https"
+            http.read_timeout = @read_timeout
+            @http_customizer&.call(http)
+            http.start { |conn| conn.request(request) }
+          end
+
+          def handle_response(request, response, response_type)
+            status = response.code.to_i
+
+            if status >= 300
+              engine_exception = deserialize_error(response).to_rest_exception
+              engine_exception.http_status_code = status
+              raise engine_exception
+            end
+
+            return nil if response_type == VOID
+            return response.body if response_type == BYTES
+            return nil if response.body.nil? || response.body.empty?
+
+            deserialize_response(response.body, response_type)
+          end
+
+          def deserialize_error(response)
+            EngineRestExceptionDto.from_json(@object_mapper.read_value(response.body.to_s))
+          rescue StandardError
+            dto = EngineRestExceptionDto.new
+            dto.message = response.body.to_s
+            dto
+          end
+
+          def deserialize_response(body, response_type)
+            parsed =
+              begin
+                @object_mapper.read_value(body)
+              rescue JSON::ParserError => e
+                raise @logger.exception_while_parsing_json_object(response_type, e)
+              end
+
+            begin
+              if response_type.is_a?(Array)
+                item_type = response_type.first
+                parsed.map { |item| item_type.from_json(item, @object_mapper) }
+              elsif response_type.respond_to?(:from_json)
+                response_type.from_json(parsed, @object_mapper)
+              else
+                parsed
+              end
+            rescue StandardError => e
+              raise @logger.exception_while_mapping_json_object(response_type, e)
+            end
+          end
+
+          def serialize_request(request_dto)
+            return nil if request_dto.nil?
+
+            @object_mapper.write_value_as_string(request_dto.as_json)
+          rescue StandardError => e
+            raise @logger.exception_while_serializing_json_object(request_dto, e)
+          end
+
+          def describe(request)
+            "#{request.method} #{request.uri}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/interceptor/auth/basic_auth_provider.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "base64"
+require_relative "../client_request_interceptor"
+require_relative "../../impl/external_task_client_logger"
+
+module Operaton
+  module Bpm
+    module Client
+      module Interceptor
+        module Auth
+          # Mirrors org.operaton.bpm.client.interceptor.auth.BasicAuthProvider
+          class BasicAuthProvider
+            include ClientRequestInterceptor
+
+            AUTHORIZATION = "Authorization"
+
+            def initialize(username, password)
+              if username.nil? || password.nil?
+                raise Client::Impl::ExternalTaskClientLogger.client_logger.basic_auth_credentials_null_exception
+              end
+
+              @username = username
+              @password = password
+            end
+
+            def intercept(request_context)
+              auth_token = "#{@username}:#{@password}"
+              request_context.add_header(AUTHORIZATION, "Basic #{encode_to_base64(auth_token)}")
+            end
+
+            protected
+
+            def encode_to_base64(decoded_string)
+              Base64.strict_encode64(decoded_string)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/interceptor/client_request_context.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Operaton
+  module Bpm
+    module Client
+      module Interceptor
+        # Mirrors org.operaton.bpm.client.interceptor.ClientRequestContext
+        module ClientRequestContext
+          def add_header(name, value)
+            raise NotImplementedError, "#{self.class} must implement #add_header"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/interceptor/client_request_interceptor.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Operaton
+  module Bpm
+    module Client
+      module Interceptor
+        # Mirrors org.operaton.bpm.client.interceptor.ClientRequestInterceptor
+        # (a functional interface in Java). Any object responding to
+        # #intercept(request_context) — including a Proc via #to_proc — works.
+        module ClientRequestInterceptor
+          def intercept(request_context)
+            raise NotImplementedError, "#{self.class} must implement #intercept"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/interceptor/impl/client_request_context_impl.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "../client_request_context"
+
+module Operaton
+  module Bpm
+    module Client
+      module Interceptor
+        module Impl
+          # Mirrors org.operaton.bpm.client.interceptor.impl.ClientRequestContextImpl
+          class ClientRequestContextImpl
+            include ClientRequestContext
+
+            attr_reader :headers
+
+            def initialize
+              @headers = {}
+            end
+
+            def add_header(name, value)
+              @headers[name] = value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/interceptor/impl/request_interceptor_handler.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "client_request_context_impl"
+require_relative "../../impl/external_task_client_logger"
+
+module Operaton
+  module Bpm
+    module Client
+      module Interceptor
+        module Impl
+          # Mirrors org.operaton.bpm.client.interceptor.impl.RequestInterceptorHandler.
+          # Applied to every outgoing HTTP request by the RequestExecutor.
+          class RequestInterceptorHandler
+            attr_reader :interceptors
+
+            def initialize(interceptors)
+              @interceptors = interceptors
+            end
+
+            # http_request is a Net::HTTPRequest; interceptor headers are added to it.
+            def process(http_request)
+              intercepted_request = ClientRequestContextImpl.new
+
+              interceptors.each do |request_interceptor|
+                if request_interceptor.respond_to?(:intercept)
+                  request_interceptor.intercept(intercepted_request)
+                else
+                  request_interceptor.call(intercepted_request)
+                end
+              rescue StandardError => e
+                Client::Impl::ExternalTaskClientLogger.engine_client_logger.request_interceptor_exception(e)
+              end
+
+              intercepted_request.headers.each do |name, value|
+                http_request[name] = value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/spi/data_format.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Operaton
+  module Bpm
+    module Client
+      module Spi
+        # Mirrors org.operaton.bpm.client.spi.DataFormat
+        module DataFormat
+          def name
+            raise NotImplementedError
+          end
+
+          def can_map(value)
+            raise NotImplementedError
+          end
+
+          def write_value(value)
+            raise NotImplementedError
+          end
+
+          def read_value(value, type_identifier_or_class)
+            raise NotImplementedError
+          end
+
+          def canonical_type_name(value)
+            raise NotImplementedError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/spi/data_format_configurator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Operaton
+  module Bpm
+    module Client
+      module Spi
+        # Mirrors org.operaton.bpm.client.spi.DataFormatConfigurator. Where
+        # Java uses java.util.ServiceLoader, configurators register themselves here.
+        module DataFormatConfigurator
+          class << self
+            def register(configurator)
+              configurators << configurator
+            end
+
+            def configurators
+              @configurators ||= []
+            end
+          end
+
+          def data_format_class
+            raise NotImplementedError
+          end
+
+          def configure(data_format)
+            raise NotImplementedError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/spi/data_format_provider.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Operaton
+  module Bpm
+    module Client
+      module Spi
+        # Mirrors org.operaton.bpm.client.spi.DataFormatProvider. Where Java
+        # uses java.util.ServiceLoader, providers register themselves here.
+        module DataFormatProvider
+          class << self
+            def register(provider)
+              providers << provider
+            end
+
+            def providers
+              @providers ||= []
+            end
+          end
+
+          def data_format_name
+            raise NotImplementedError
+          end
+
+          def create_instance
+            raise NotImplementedError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/task/external_task.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Operaton
+  module Bpm
+    module Client
+      module Task
+        # Mirrors org.operaton.bpm.client.task.ExternalTask. Documents the
+        # contract implemented by Task::Impl::ExternalTaskImpl.
+        module ExternalTask
+          INTERFACE_METHODS = %i[
+            activity_id activity_instance_id error_message error_details
+            execution_id id lock_expiration_time create_time
+            process_definition_id process_definition_key process_definition_version_tag
+            process_instance_id retries worker_id topic_name tenant_id priority
+            variable variable_typed all_variables all_variables_typed
+            business_key extension_property extension_properties
+          ].freeze
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/task/external_task_handler.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Operaton
+  module Bpm
+    module Client
+      module Task
+        # Mirrors org.operaton.bpm.client.task.ExternalTaskHandler, a
+        # functional interface. Handlers may be any object responding to
+        # #execute(external_task, external_task_service) or any callable
+        # (Proc/lambda) taking the same two arguments.
+        module ExternalTaskHandler
+          def execute(external_task, external_task_service)
+            raise NotImplementedError, "#{self.class} must implement #execute"
+          end
+
+          # Invokes a handler regardless of which convention it follows.
+          def self.invoke(handler, external_task, external_task_service)
+            if handler.respond_to?(:execute)
+              handler.execute(external_task, external_task_service)
+            else
+              handler.call(external_task, external_task_service)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/task/external_task_service.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Operaton
+  module Bpm
+    module Client
+      module Task
+        # Mirrors org.operaton.bpm.client.task.ExternalTaskService. The Java
+        # overloads accepting either an ExternalTask or an id are collapsed
+        # into single Ruby methods that accept either.
+        module ExternalTaskService
+          INTERFACE_METHODS = %i[
+            lock unlock complete set_variables handle_failure handle_bpmn_error extend_lock
+          ].freeze
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/task/impl/dto/bpmn_error_request_dto.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "../../../impl/request_dto"
+
+module Operaton
+  module Bpm
+    module Client
+      module Task
+        module Impl
+          module Dto
+            # Mirrors org.operaton.bpm.client.task.impl.dto.BpmnErrorRequestDto
+            class BpmnErrorRequestDto < Client::Impl::RequestDto
+              attr_reader :error_code, :error_message, :variables
+
+              def initialize(worker_id, error_code, error_message = nil, variables = nil)
+                super(worker_id)
+                @error_code = error_code
+                @error_message = error_message
+                @variables = variables
+              end
+
+              def as_json
+                super.merge(
+                  "errorCode" => error_code,
+                  "errorMessage" => error_message,
+                  "variables" => variables&.transform_values(&:as_json)
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/task/impl/dto/complete_request_dto.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../../../impl/request_dto"
+
+module Operaton
+  module Bpm
+    module Client
+      module Task
+        module Impl
+          module Dto
+            # Mirrors org.operaton.bpm.client.task.impl.dto.CompleteRequestDto
+            class CompleteRequestDto < Client::Impl::RequestDto
+              attr_reader :variables, :local_variables
+
+              def initialize(worker_id, variables, local_variables)
+                super(worker_id)
+                @variables = variables
+                @local_variables = local_variables
+              end
+
+              def as_json
+                super.merge(
+                  "variables" => variables&.transform_values(&:as_json),
+                  "localVariables" => local_variables&.transform_values(&:as_json)
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/task/impl/dto/extend_lock_request_dto.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../../../impl/request_dto"
+
+module Operaton
+  module Bpm
+    module Client
+      module Task
+        module Impl
+          module Dto
+            # Mirrors org.operaton.bpm.client.task.impl.dto.ExtendLockRequestDto
+            class ExtendLockRequestDto < Client::Impl::RequestDto
+              attr_reader :new_duration
+
+              def initialize(worker_id, new_duration)
+                super(worker_id)
+                @new_duration = new_duration
+              end
+
+              def as_json
+                super.merge("newDuration" => new_duration)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/task/impl/dto/failure_request_dto.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../../../impl/request_dto"
+
+module Operaton
+  module Bpm
+    module Client
+      module Task
+        module Impl
+          module Dto
+            # Mirrors org.operaton.bpm.client.task.impl.dto.FailureRequestDto
+            class FailureRequestDto < Client::Impl::RequestDto
+              attr_reader :error_message, :error_details, :retries, :retry_timeout,
+                          :variables, :local_variables
+
+              def initialize(worker_id, error_message, error_details, retries, retry_timeout,
+                             variables = nil, local_variables = nil)
+                super(worker_id)
+                @error_message = error_message
+                @error_details = error_details
+                @retries = retries
+                @retry_timeout = retry_timeout
+                @variables = variables
+                @local_variables = local_variables
+              end
+
+              def as_json
+                super.merge(
+                  "errorMessage" => error_message,
+                  "errorDetails" => error_details,
+                  "retries" => retries,
+                  "retryTimeout" => retry_timeout,
+                  "variables" => variables&.transform_values(&:as_json),
+                  "localVariables" => local_variables&.transform_values(&:as_json)
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/client/task/impl/dto/lock_request_dto.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../../../impl/request_dto"
+
+module Operaton
+  module Bpm
+    module Client
+      module Task
+        module Impl
+          module Dto
+            # Mirrors org.operaton.bpm.client.task.impl.dto.LockRequestDto
+            class LockRequestDto < Client::Impl::RequestDto
+              attr_reader :lock_duration
+
+              def initialize(worker_id, lock_duration)
+                super(worker_id)
+                @lock_duration = lock_duration
+              end
+
+              def as_json
+                super.merge("lockDuration" => lock_duration)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end