operaton-bpm-client 0.1.0

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

@@ -0,0 +1,349 @@
+# frozen_string_literal: true
+
+require "socket"
+require "securerandom"
+
+require_relative "../external_task_client_builder"
+require_relative "external_task_client_logger"
+require_relative "external_task_client_impl"
+require_relative "permanent_url_resolver"
+require_relative "object_mapper"
+require_relative "engine_client"
+require_relative "request_executor"
+require_relative "../backoff/exponential_backoff_strategy"
+require_relative "../interceptor/impl/request_interceptor_handler"
+require_relative "../task/ordering_config"
+require_relative "../topic/impl/topic_subscription_manager"
+require_relative "../spi/data_format_provider"
+require_relative "../spi/data_format_configurator"
+require_relative "../variable/client_values"
+require_relative "../variable/impl/default_value_mappers"
+require_relative "../variable/impl/typed_values"
+require_relative "../variable/impl/mapper/boolean_value_mapper"
+require_relative "../variable/impl/mapper/byte_array_value_mapper"
+require_relative "../variable/impl/mapper/date_value_mapper"
+require_relative "../variable/impl/mapper/double_value_mapper"
+require_relative "../variable/impl/mapper/file_value_mapper"
+require_relative "../variable/impl/mapper/integer_value_mapper"
+require_relative "../variable/impl/mapper/json_value_mapper"
+require_relative "../variable/impl/mapper/long_value_mapper"
+require_relative "../variable/impl/mapper/null_value_mapper"
+require_relative "../variable/impl/mapper/object_value_mapper"
+require_relative "../variable/impl/mapper/short_value_mapper"
+require_relative "../variable/impl/mapper/string_value_mapper"
+require_relative "../variable/impl/mapper/xml_value_mapper"
+require_relative "../variable/impl/format/json/json_data_format_provider"
+
+module Operaton
+  module Bpm
+    module Client
+      module Impl
+        # Mirrors org.operaton.bpm.client.impl.ExternalTaskClientBuilderImpl
+        class ExternalTaskClientBuilderImpl
+          include ExternalTaskClientBuilder
+
+          attr_reader :object_mapper, :value_mappers, :typed_values, :engine_client
+
+          def initialize
+            # default values
+            @worker_id = nil
+            @max_tasks = 10
+            @use_priority = true
+            @ordering_config = Task::OrderingConfig.empty
+            @async_response_timeout = nil
+            @lock_duration = 20_000
+            @default_serialization_format = Engine::Variable::Variables::SerializationDataFormats::JSON
+            @date_format = ObjectMapper::DEFAULT_DATE_FORMAT
+            @interceptors = []
+            @is_auto_fetching_enabled = true
+            @backoff_strategy = Backoff::ExponentialBackoffStrategy.new
+            @is_backoff_strategy_disabled = false
+            @http_customizer = nil
+            @url_resolver = PermanentUrlResolver.new(nil)
+            @object_mapper = nil
+            @value_mappers = nil
+            @typed_values = nil
+            @engine_client = nil
+            @topic_subscription_manager = nil
+          end
+
+          def base_url(base_url)
+            @url_resolver = PermanentUrlResolver.new(base_url)
+            self
+          end
+
+          def url_resolver(url_resolver)
+            @url_resolver = url_resolver
+            self
+          end
+
+          def worker_id(worker_id)
+            @worker_id = worker_id
+            self
+          end
+
+          def add_interceptor(interceptor)
+            @interceptors << interceptor
+            self
+          end
+
+          def max_tasks(max_tasks)
+            @max_tasks = max_tasks
+            self
+          end
+
+          def use_priority(use_priority)
+            @use_priority = use_priority
+            self
+          end
+
+          def use_create_time(use_create_time)
+            if use_create_time
+              @ordering_config.configure_field(Task::OrderingConfig::SortingField::CREATE_TIME)
+              @ordering_config.configure_direction_on_last_field(Task::OrderingConfig::Direction::DESC)
+            end
+            self
+          end
+
+          def order_by_create_time
+            @ordering_config.configure_field(Task::OrderingConfig::SortingField::CREATE_TIME)
+            self
+          end
+
+          def asc
+            @ordering_config.configure_direction_on_last_field(Task::OrderingConfig::Direction::ASC)
+            self
+          end
+
+          def desc
+            @ordering_config.configure_direction_on_last_field(Task::OrderingConfig::Direction::DESC)
+            self
+          end
+
+          def async_response_timeout(async_response_timeout)
+            @async_response_timeout = async_response_timeout
+            self
+          end
+
+          def lock_duration(lock_duration)
+            @lock_duration = lock_duration
+            self
+          end
+
+          def disable_auto_fetching
+            @is_auto_fetching_enabled = false
+            self
+          end
+
+          def backoff_strategy(backoff_strategy)
+            @backoff_strategy = backoff_strategy
+            self
+          end
+
+          def disable_backoff_strategy
+            @is_backoff_strategy_disabled = true
+            self
+          end
+
+          def default_serialization_format(default_serialization_format)
+            @default_serialization_format = default_serialization_format
+            self
+          end
+
+          # A Ruby strftime pattern (default "%Y-%m-%dT%H:%M:%S.%L%z", the
+          # equivalent of the Java client's "yyyy-MM-dd'T'HH:mm:ss.SSSZ").
+          def date_format(date_format)
+            @date_format = date_format
+            self
+          end
+
+          # Accepts a block invoked with the Net::HTTP instance of every request.
+          def customize_http_client(customizer = nil, &block)
+            @http_customizer = customizer || block
+            self
+          end
+
+          def build
+            raise logger.max_tasks_not_greater_than_zero_exception(@max_tasks) if @max_tasks <= 0
+
+            if !@async_response_timeout.nil? && @async_response_timeout <= 0
+              raise logger.async_response_timeout_not_greater_than_zero_exception(@async_response_timeout)
+            end
+
+            raise logger.lock_duration_is_not_greater_than_zero_exception(@lock_duration) if @lock_duration <= 0
+
+            raise logger.base_url_null_exception if @url_resolver.nil? || get_base_url.nil? || get_base_url.empty?
+
+            check_interceptors
+            @ordering_config.validate_ordering_properties
+
+            init_base_url
+            init_worker_id
+            init_object_mapper
+            init_engine_client
+            init_variable_mappers
+            init_topic_subscription_manager
+
+            ExternalTaskClientImpl.new(@topic_subscription_manager)
+          end
+
+          def get_base_url # rubocop:disable Naming/AccessorMethodName
+            @url_resolver.base_url
+          end
+
+          def get_default_serialization_format # rubocop:disable Naming/AccessorMethodName
+            @default_serialization_format
+          end
+
+          def get_date_format # rubocop:disable Naming/AccessorMethodName
+            @date_format
+          end
+
+          protected
+
+          def init_base_url
+            @url_resolver.base_url = sanitize_url(@url_resolver.base_url) if @url_resolver.is_a?(PermanentUrlResolver)
+          end
+
+          def sanitize_url(url)
+            url.strip.sub(%r{/+\z}, "")
+          end
+
+          def init_worker_id
+            return unless @worker_id.nil?
+
+            hostname = check_hostname
+            @worker_id = "#{hostname}#{SecureRandom.uuid}"
+          end
+
+          def check_interceptors
+            @interceptors.each do |interceptor|
+              raise logger.interceptor_null_exception if interceptor.nil?
+            end
+          end
+
+          def init_object_mapper
+            @object_mapper = ObjectMapper.new(@date_format)
+          end
+
+          def init_engine_client
+            request_interceptor_handler = Interceptor::Impl::RequestInterceptorHandler.new(@interceptors)
+            request_executor = RequestExecutor.new(
+              @object_mapper,
+              interceptor_handler: request_interceptor_handler,
+              http_customizer: @http_customizer,
+              read_timeout: compute_read_timeout
+            )
+            @engine_client = EngineClient.new(@worker_id, @max_tasks, @async_response_timeout, @url_resolver,
+                                              request_executor, @use_priority, @ordering_config)
+          end
+
+          def init_variable_mappers
+            @value_mappers = Variable::Impl::DefaultValueMappers.new(@default_serialization_format)
+
+            @value_mappers.add_mapper(Variable::Impl::Mapper::NullValueMapper.new)
+            @value_mappers.add_mapper(Variable::Impl::Mapper::BooleanValueMapper.new)
+            @value_mappers.add_mapper(Variable::Impl::Mapper::StringValueMapper.new)
+            @value_mappers.add_mapper(Variable::Impl::Mapper::DateValueMapper.new(@date_format))
+            @value_mappers.add_mapper(Variable::Impl::Mapper::ByteArrayValueMapper.new)
+
+            # number mappers
+            @value_mappers.add_mapper(Variable::Impl::Mapper::IntegerValueMapper.new)
+            @value_mappers.add_mapper(Variable::Impl::Mapper::LongValueMapper.new)
+            @value_mappers.add_mapper(Variable::Impl::Mapper::ShortValueMapper.new)
+            @value_mappers.add_mapper(Variable::Impl::Mapper::DoubleValueMapper.new)
+
+            # object
+            lookup_data_formats.each do |key, format|
+              @value_mappers.add_mapper(Variable::Impl::Mapper::ObjectValueMapper.new(key, format))
+            end
+
+            # json/xml
+            @value_mappers.add_mapper(Variable::Impl::Mapper::JsonValueMapper.new)
+            @value_mappers.add_mapper(Variable::Impl::Mapper::XmlValueMapper.new)
+
+            # file
+            @value_mappers.add_mapper(Variable::Impl::Mapper::FileValueMapper.new(@engine_client))
+
+            @typed_values = Variable::Impl::TypedValues.new(@value_mappers)
+            @engine_client.typed_values = @typed_values
+          end
+
+          def init_topic_subscription_manager
+            @topic_subscription_manager = Topic::Impl::TopicSubscriptionManager.new(
+              @engine_client, @typed_values, @lock_duration
+            )
+            @topic_subscription_manager.backoff_strategy = @backoff_strategy
+            @topic_subscription_manager.disable_backoff_strategy if @is_backoff_strategy_disabled
+            @topic_subscription_manager.start if auto_fetching_enabled?
+          end
+
+          def lookup_data_formats
+            data_formats = {}
+            lookup_custom_data_formats(data_formats)
+            apply_configurators(data_formats)
+            data_formats
+          end
+
+          def lookup_custom_data_formats(data_formats)
+            Spi::DataFormatProvider.providers.each do |provider|
+              logger.log_data_format_provider(provider)
+              lookup_provider(data_formats, provider)
+            end
+          end
+
+          def lookup_provider(data_formats, provider)
+            data_format_name = provider.data_format_name
+            raise logger.multiple_providers_for_dataformat(data_format_name) if data_formats.key?(data_format_name)
+
+            data_format_instance = provider.create_instance
+            data_formats[data_format_name] = data_format_instance
+            logger.log_data_format(data_format_instance)
+          end
+
+          def apply_configurators(data_formats)
+            Spi::DataFormatConfigurator.configurators.each do |configurator|
+              logger.log_data_format_configurator(configurator)
+              apply_configurator(data_formats, configurator)
+            end
+          end
+
+          def apply_configurator(data_formats, configurator)
+            data_formats.each_value do |data_format|
+              configurator.configure(data_format) if data_format.is_a?(configurator.data_format_class)
+            end
+          end
+
+          def check_hostname
+            hostname = get_hostname
+            raise logger.cannot_get_hostname_exception(nil) if hostname.nil? || hostname.empty?
+
+            hostname
+          rescue StandardError => e
+            raise logger.cannot_get_hostname_exception(e)
+          end
+
+          def get_hostname # rubocop:disable Naming/AccessorMethodName
+            Socket.gethostname
+          end
+
+          def auto_fetching_enabled?
+            @is_auto_fetching_enabled
+          end
+
+          def compute_read_timeout
+            if @async_response_timeout
+              (@async_response_timeout / 1000.0) + 30
+            else
+              60
+            end
+          end
+
+          def logger
+            ExternalTaskClientLogger.client_logger
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../topic/impl/topic_subscription_builder_impl"
+
+module Operaton
+  module Bpm
+    module Client
+      module Impl
+        # Mirrors org.operaton.bpm.client.impl.ExternalTaskClientImpl
+        class ExternalTaskClientImpl
+          attr_reader :topic_subscription_manager
+
+          def initialize(topic_subscription_manager)
+            @topic_subscription_manager = topic_subscription_manager
+          end
+
+          # Creates a fluent builder to create and configure a topic subscription.
+          def subscribe(topic_name)
+            Topic::Impl::TopicSubscriptionBuilderImpl.new(topic_name, topic_subscription_manager)
+          end
+
+          # Stops continuous fetching and locking of tasks.
+          def stop
+            topic_subscription_manager.stop
+          end
+
+          # Starts continuous fetching and locking of tasks.
+          def start
+            topic_subscription_manager.start
+          end
+
+          # True while the client is actively fetching tasks.
+          def active?
+            topic_subscription_manager.running?
+          end
+          alias is_active? active?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require "logger"
+require_relative "../exceptions"
+
+module Operaton
+  module Bpm
+    module Client
+      class << self
+        # Library-wide logger, mirroring the "org.operaton.bpm.client" SLF4J logger.
+        attr_writer :logger
+
+        def logger
+          @logger ||= Logger.new($stderr, progname: "org.operaton.bpm.client")
+        end
+      end
+
+      module Impl
+        # Mirrors org.operaton.bpm.client.impl.ExternalTaskClientLogger
+        class ExternalTaskClientLogger
+          PROJECT_CODE = "TASK/CLIENT"
+
+          def self.client_logger
+            @client_logger ||= new("01")
+          end
+
+          def self.engine_client_logger
+            @engine_client_logger ||= EngineClientLogger.new("02")
+          end
+
+          def self.topic_subscription_manager_logger
+            @topic_subscription_manager_logger ||= Topic::Impl::TopicSubscriptionManagerLogger.new("03")
+          end
+
+          def initialize(component_id)
+            @component_id = component_id
+          end
+
+          def exception_message(id, message_template, *args)
+            "#{PROJECT_CODE}-#{@component_id}#{id} #{format_template(message_template, *args)}"
+          end
+
+          def format_template(template, *args)
+            args.reduce(template) { |msg, arg| msg.sub("{}", arg.to_s) }
+          end
+
+          def log_error(id, message_template, error = nil, *args)
+            msg = exception_message(id, message_template, *args)
+            msg += " : #{error.class}: #{error.message}" if error
+            Client.logger.error(msg)
+          end
+
+          def log_info(id, message_template, *args)
+            Client.logger.info(exception_message(id, message_template, *args))
+          end
+
+          def log_debug(id, message_template, *args)
+            Client.logger.debug(exception_message(id, message_template, *args))
+          end
+
+          def base_url_null_exception
+            ExternalTaskClientException.new(exception_message(
+              "001", "Base URL cannot be null or an empty string"))
+          end
+
+          def cannot_get_hostname_exception(cause)
+            ExternalTaskClientException.new(exception_message("002", "Cannot get hostname"), cause)
+          end
+
+          def double_direction_config_exception
+            ExternalTaskClientException.new(
+              "Invalid query: can specify only one direction desc() or asc() for an ordering constraint")
+          end
+
+          def unspecified_order_by_method_exception
+            ExternalTaskClientException.new(
+              "Invalid query: You should call any of the orderBy methods first before specifying a direction")
+          end
+
+          def missing_direction_exception
+            ExternalTaskClientException.new(
+              "Invalid query: call asc() or desc() after using orderByXX()")
+          end
+
+          def topic_name_null_exception
+            ExternalTaskClientException.new(exception_message(
+              "003", "Topic name cannot be null"))
+          end
+
+          def lock_duration_is_not_greater_than_zero_exception(lock_duration)
+            ExternalTaskClientException.new(exception_message(
+              "004", "Lock duration must be greater than 0, but was '{}'", lock_duration))
+          end
+
+          def external_task_handler_null_exception
+            ExternalTaskClientException.new(exception_message(
+              "005", "External task handler cannot be null"))
+          end
+
+          def topic_name_already_subscribed_exception(topic_name)
+            ExternalTaskClientException.new(exception_message(
+              "006", "Topic name '{}' has already been subscribed", topic_name))
+          end
+
+          # Mirrors handledEngineClientException: maps EngineClientException
+          # causes to the public exception hierarchy.
+          def handled_engine_client_exception(action_name, error)
+            caused = error.cause
+
+            if caused.is_a?(RestException)
+              message = caused.message
+              status = caused.http_status_code
+
+              return case status
+                     when 400 then BadRequestException.new(create_message("007", action_name, message), caused)
+                     when 404 then NotFoundException.new(create_message("008", action_name, message), caused)
+                     when 500 then EngineException.new(create_message("009", action_name, message), caused)
+                     else
+                       UnknownHttpErrorException.new(exception_message(
+                         "031", "Exception while {}: The request failed with status code {} and message: \"{}\"",
+                         action_name, status, message), caused)
+                     end
+            end
+
+            if io_error?(caused)
+              return ConnectionLostException.new(exception_message(
+                "010", "Exception while {}: Connection could not be established with message: \"{}\"",
+                action_name, caused.message), caused)
+            end
+
+            ExternalTaskClientException.new(exception_message(
+              "011", "Exception while {}: ", action_name), error)
+          end
+
+          def create_message(id, action_name, message)
+            exception_message(id, "Exception while {}: {}", action_name, message)
+          end
+
+          def basic_auth_credentials_null_exception
+            ExternalTaskClientException.new(exception_message(
+              "012", "Basic authentication credentials (username, password) cannot be null"))
+          end
+
+          def interceptor_null_exception
+            ExternalTaskClientException.new(exception_message(
+              "013", "Interceptor cannot be null"))
+          end
+
+          def max_tasks_not_greater_than_zero_exception(max_tasks)
+            ExternalTaskClientException.new(exception_message(
+              "014", "Maximum amount of fetched tasks must be greater than zero, but was '{}'", max_tasks))
+          end
+
+          def async_response_timeout_not_greater_than_zero_exception(async_response_timeout)
+            ExternalTaskClientException.new(exception_message(
+              "015", "Asynchronous response timeout must be greater than zero, but was '{}'", async_response_timeout))
+          end
+
+          def value_mapper_exception_while_parsing_date(date, error)
+            ValueMapperException.new(exception_message(
+              "018", "Exception while mapping value: Cannot parse date '{}'", date), error)
+          end
+
+          def value_mapper_exception_due_to_no_object_type_name
+            ValueMapperException.new(exception_message(
+              "019", "Exception while mapping value: " \
+                     "Cannot write serialized value for variable: no 'objectTypeName' provided for non-null value."))
+          end
+
+          def value_mapper_exception_while_serializing_object(error)
+            ValueMapperException.new(exception_message(
+              "020", "Exception while mapping value: Cannot serialize object in variable."), error)
+          end
+
+          def value_mapper_exception_while_deserializing_object(error)
+            ValueMapperException.new(exception_message(
+              "021", "Exception while mapping value: Cannot deserialize object in variable."), error)
+          end
+
+          def value_mapper_exception_while_serializing_abstract_value(name)
+            ValueMapperException.new(exception_message(
+              "022", "Cannot serialize value of abstract type '{}'", name))
+          end
+
+          def value_mapper_exception_due_to_serializer_not_found_for_typed_value(typed_value)
+            ValueMapperException.new(exception_message(
+              "023", "Cannot find serializer for value '{}'", typed_value))
+          end
+
+          def value_mapper_exception_due_to_serializer_not_found_for_typed_value_field(value)
+            ValueMapperException.new(exception_message(
+              "024", "Cannot find serializer for value '{}'", value))
+          end
+
+          def cannot_serialize_variable(variable_name, error)
+            ValueMapperException.new(exception_message(
+              "025", "Cannot serialize variable '{}'", variable_name), error)
+          end
+
+          def log_data_format_provider(provider)
+            log_info("026", "Discovered data format provider: {}[name = {}]",
+                     provider.class.name, provider.data_format_name)
+          end
+
+          def log_data_format(data_format)
+            log_info("025", "Discovered data format: {}[name = {}]", data_format.class.name, data_format.name)
+          end
+
+          def log_data_format_configurator(configurator)
+            log_info("027", "Discovered data format configurator: {}[dataformat = {}]",
+                     configurator.class.name, configurator.data_format_class.name)
+          end
+
+          def multiple_providers_for_dataformat(data_format_name)
+            ExternalTaskClientException.new(exception_message(
+              "028", "Multiple providers found for dataformat '{}'", data_format_name))
+          end
+
+          def pass_null_value_parameter(parameter_name)
+            ExternalTaskClientException.new(exception_message(
+              "030", "Null value is not allowed as '{}'", parameter_name))
+          end
+
+          private
+
+          def io_error?(error)
+            error.is_a?(IOError) || error.is_a?(SystemCallError) || error.is_a?(SocketError) ||
+              error.is_a?(Timeout::Error) || error.is_a?(OpenSSL::SSL::SSLError)
+          rescue NameError
+            error.is_a?(IOError) || error.is_a?(SystemCallError)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module Operaton
+  module Bpm
+    module Client
+      module Impl
+        # Stands in for the configured Jackson ObjectMapper: JSON encoding and
+        # decoding plus date handling with the client's configured date format.
+        #
+        # The date format is a Ruby strftime pattern. The default corresponds to
+        # the Java client's "yyyy-MM-dd'T'HH:mm:ss.SSSZ".
+        class ObjectMapper
+          DEFAULT_DATE_FORMAT = "%Y-%m-%dT%H:%M:%S.%L%z"
+
+          attr_reader :date_format
+
+          def initialize(date_format = DEFAULT_DATE_FORMAT)
+            @date_format = date_format
+          end
+
+          def write_value_as_string(value)
+            JSON.generate(value)
+          end
+
+          def read_value(json_string)
+            JSON.parse(json_string)
+          end
+
+          def format_date(time)
+            time = time.to_time if !time.is_a?(Time) && time.respond_to?(:to_time)
+            time.strftime(date_format)
+          end
+
+          def parse_date(string)
+            Time.strptime(string, date_format)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../url_resolver"
+
+module Operaton
+  module Bpm
+    module Client
+      module Impl
+        # Mirrors org.operaton.bpm.client.impl.PermanentUrlResolver
+        class PermanentUrlResolver
+          include UrlResolver
+
+          attr_accessor :base_url
+
+          def initialize(base_url)
+            @base_url = base_url
+          end
+        end
+      end
+    end
+  end
+end