temporal-ruby 0.0.0 → 0.0.1.pre.pre1

data/lib/temporal/activity/context.rb

@@ -0,0 +1,64 @@
+# This context class is available in the activity implementation
+# and provides context and methods for interacting with Temporal
+#
+require 'temporal/uuid'
+require 'temporal/activity/async_token'
+
+module Temporal
+  class Activity
+    class Context
+      def initialize(client, metadata)
+        @client = client
+        @metadata = metadata
+        @async = false
+      end
+
+      def async
+        @async = true
+      end
+
+      def async?
+        @async
+      end
+
+      def async_token
+        AsyncToken.encode(
+          metadata.namespace,
+          metadata.id,
+          metadata.workflow_id,
+          metadata.workflow_run_id
+        )
+      end
+
+      def heartbeat(details = nil)
+        logger.debug('Activity heartbeat')
+        client.record_activity_task_heartbeat(task_token: task_token, details: details)
+      end
+
+      def logger
+        Temporal.logger
+      end
+
+      def run_idem
+        UUID.v5(metadata.workflow_run_id.to_s, metadata.id.to_s)
+      end
+      alias idem run_idem
+
+      def workflow_idem
+        UUID.v5(metadata.workflow_id.to_s, metadata.id.to_s)
+      end
+
+      def headers
+        metadata.headers
+      end
+
+      private
+
+      attr_reader :client, :metadata
+
+      def task_token
+        metadata.task_token
+      end
+    end
+  end
+end

data/lib/temporal/activity/poller.rb

@@ -0,0 +1,79 @@
+require 'temporal/client'
+require 'temporal/thread_pool'
+require 'temporal/middleware/chain'
+require 'temporal/activity/task_processor'
+
+module Temporal
+  class Activity
+    class Poller
+      THREAD_POOL_SIZE = 20
+
+      def initialize(namespace, task_queue, activity_lookup, middleware = [])
+        @namespace = namespace
+        @task_queue = task_queue
+        @activity_lookup = activity_lookup
+        @middleware = middleware
+        @shutting_down = false
+      end
+
+      def start
+        @shutting_down = false
+        @thread = Thread.new(&method(:poll_loop))
+      end
+
+      def stop
+        @shutting_down = true
+        Thread.new { Temporal.logger.info('Shutting down activity poller') }.join
+      end
+
+      def wait
+        thread.join
+      end
+
+      private
+
+      attr_reader :namespace, :task_queue, :activity_lookup, :middleware, :thread
+
+      def client
+        @client ||= Temporal::Client.generate
+      end
+
+      def shutting_down?
+        @shutting_down
+      end
+
+      def poll_loop
+        loop do
+          thread_pool.wait_for_available_threads
+
+          return if shutting_down?
+
+          Temporal.logger.debug("Polling activity task queue (#{namespace} / #{task_queue})")
+
+          task = poll_for_task
+          next unless task&.activity_type
+
+          thread_pool.schedule { process(task) }
+        end
+      end
+
+      def poll_for_task
+        client.poll_activity_task_queue(namespace: namespace, task_queue: task_queue)
+      rescue StandardError => error
+        Temporal.logger.error("Unable to poll activity task queue: #{error.inspect}")
+        nil
+      end
+
+      def process(task)
+        client = Temporal::Client.generate
+        middleware_chain = Middleware::Chain.new(middleware)
+
+        TaskProcessor.new(task, namespace, activity_lookup, client, middleware_chain).process
+      end
+
+      def thread_pool
+        @thread_pool ||= ThreadPool.new(THREAD_POOL_SIZE)
+      end
+    end
+  end
+end

data/lib/temporal/activity/task_processor.rb

@@ -0,0 +1,78 @@
+require 'temporal/metadata'
+require 'temporal/errors'
+require 'temporal/activity/context'
+require 'temporal/json'
+
+module Temporal
+  class Activity
+    class TaskProcessor
+      def initialize(task, namespace, activity_lookup, client, middleware_chain)
+        @task = task
+        @namespace = namespace
+        @task_token = task.task_token
+        @activity_name = task.activity_type.name
+        @activity_class = activity_lookup.find(activity_name)
+        @client = client
+        @middleware_chain = middleware_chain
+      end
+
+      def process
+        start_time = Time.now
+
+        Temporal.logger.info("Processing activity task for #{activity_name}")
+        Temporal.metrics.timing('activity_task.queue_time', queue_time_ms, activity: activity_name)
+
+        if !activity_class
+          raise ActivityNotRegistered, 'Activity is not registered with this worker'
+        end
+
+        metadata = Metadata.generate(Metadata::ACTIVITY_TYPE, task, namespace)
+        context = Activity::Context.new(client, metadata)
+
+        result = middleware_chain.invoke(metadata) do
+          activity_class.execute_in_context(context, parse_payload(task.input))
+        end
+
+        # Do not complete asynchronous activities, these should be completed manually
+        respond_completed(result) unless context.async?
+      rescue StandardError, ScriptError => error
+        respond_failed(error)
+      ensure
+        time_diff_ms = ((Time.now - start_time) * 1000).round
+        Temporal.metrics.timing('activity_task.latency', time_diff_ms, activity: activity_name)
+        Temporal.logger.debug("Activity task processed in #{time_diff_ms}ms")
+      end
+
+      private
+
+      attr_reader :task, :namespace, :task_token, :activity_name, :activity_class, :client, :middleware_chain
+
+      def queue_time_ms
+        scheduled = task.current_attempt_scheduled_time.to_f
+        started = task.started_time.to_f
+        ((started - scheduled) * 1_000).round
+      end
+
+      def respond_completed(result)
+        Temporal.logger.info("Activity #{activity_name} completed")
+        client.respond_activity_task_completed(task_token: task_token, result: result)
+      rescue StandardError => error
+        Temporal.logger.error("Unable to complete Activity #{activity_name}: #{error.inspect}")
+      end
+
+      def respond_failed(error)
+        Temporal.logger.error("Activity #{activity_name} failed with: #{error.inspect}")
+        client.respond_activity_task_failed(task_token: task_token, exception: error)
+      rescue StandardError => error
+        Temporal.logger.error("Unable to fail Activity #{activity_name}: #{error.inspect}")
+      end
+
+      def parse_payload(payload)
+        return if payload.nil? || payload.payloads.empty?
+
+        binary = payload.payloads.first.data
+        JSON.deserialize(binary)
+      end
+    end
+  end
+end

data/lib/temporal/activity/workflow_convenience_methods.rb

@@ -0,0 +1,41 @@
+# This module provides a set of methods for imitating direct Activities calls
+# from within Workflows:
+#
+# class TestWorkflow < Temporal::Workflow
+#   def execute
+#     TestActivity.execute!('foo', 'bar')
+#   end
+# end
+#
+# This is analogous to calling:
+#
+# workflow.execute_activity(TestActivity, 'foo', 'bar')
+#
+require 'temporal/thread_local_context'
+
+module Temporal
+  class Activity
+    module WorkflowConvenienceMethods
+      def execute(*input, **args)
+        context = Temporal::ThreadLocalContext.get
+        raise 'Called Activity#execute outside of a Workflow context' unless context
+
+        context.execute_activity(self, *input, **args)
+      end
+
+      def execute!(*input, **args)
+        context = Temporal::ThreadLocalContext.get
+        raise 'Called Activity#execute! outside of a Workflow context' unless context
+
+        context.execute_activity!(self, *input, **args)
+      end
+
+      def execute_locally(*input, **args)
+        context = Temporal::ThreadLocalContext.get
+        raise 'Called Activity#execute_locally outside of a Workflow context' unless context
+
+        context.execute_local_activity(self, *input, **args)
+      end
+    end
+  end
+end

data/lib/temporal/client.rb

@@ -0,0 +1,21 @@
+require 'temporal/client/grpc_client'
+
+module Temporal
+  module Client
+    CLIENT_TYPES_MAP = {
+      grpc: Temporal::Client::GRPCClient
+    }.freeze
+
+    def self.generate
+      client_class = CLIENT_TYPES_MAP[Temporal.configuration.client_type]
+      host = Temporal.configuration.host
+      port = Temporal.configuration.port
+
+      hostname = `hostname`
+      thread_id = Thread.current.object_id
+      identity = "#{thread_id}@#{hostname}"
+
+      client_class.new(host, port, identity)
+    end
+  end
+end

data/lib/temporal/client/errors.rb

@@ -0,0 +1,8 @@
+module Temporal
+  module Client
+    class Error < StandardError; end
+
+    # incorrect arguments passed to the client
+    class ArgumentError < Error; end
+  end
+end

data/lib/temporal/client/grpc_client.rb

@@ -0,0 +1,345 @@
+require 'grpc'
+require 'google/protobuf/well_known_types'
+require 'securerandom'
+require 'temporal/json'
+require 'temporal/client/errors'
+require 'temporal/client/serializer'
+require 'temporal/client/serializer/payload'
+require 'temporal/client/serializer/failure'
+require 'gen/temporal/api/workflowservice/v1/service_services_pb'
+
+module Temporal
+  module Client
+    class GRPCClient
+      WORKFLOW_ID_REUSE_POLICY = {
+        allow_failed: Temporal::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY,
+        allow: Temporal::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE,
+        reject: Temporal::Api::Enums::V1::WorkflowIdReusePolicy::WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE
+      }.freeze
+
+      def initialize(host, port, identity)
+        @url = "#{host}:#{port}"
+        @identity = identity
+      end
+
+      def register_namespace(name:, description: nil, global: false, retention_period: 10)
+        request = Temporal::Api::WorkflowService::V1::RegisterNamespaceRequest.new(
+          name: name,
+          description: description,
+          is_global_namespace: global,
+          workflow_execution_retention_period: Google::Protobuf::Duration.new(
+            seconds: retention_period * 24 * 60 * 60
+          )
+        )
+        client.register_namespace(request)
+      rescue GRPC::AlreadyExists => e
+        raise Temporal::NamespaceAlreadyExistsFailure, e.details
+      end
+
+      def describe_namespace(name:)
+        request = Temporal::Api::WorkflowService::V1::DescribeNamespaceRequest.new(name: name)
+        client.describe_namespace(request)
+      end
+
+      def list_namespaces(page_size:)
+        request = Temporal::Api::WorkflowService::V1::ListNamespacesRequest.new(pageSize: page_size)
+        client.list_namespaces(request)
+      end
+
+      def update_namespace(name:, description:)
+        request = Temporal::Api::WorkflowService::V1::UpdateNamespaceRequest.new(
+          name: name,
+          update_info: Temporal::Api::WorkflowService::V1::UpdateNamespaceInfo.new(
+            description: description
+          )
+        )
+        client.update_namespace(request)
+      end
+
+      def deprecate_namespace(name:)
+        request = Temporal::Api::WorkflowService::V1::DeprecateNamespaceRequest.new(name: name)
+        client.deprecate_namespace(request)
+      end
+
+      def start_workflow_execution(
+        namespace:,
+        workflow_id:,
+        workflow_name:,
+        task_queue:,
+        input: nil,
+        execution_timeout:,
+        task_timeout:,
+        workflow_id_reuse_policy: nil,
+        headers: nil
+      )
+        request = Temporal::Api::WorkflowService::V1::StartWorkflowExecutionRequest.new(
+          identity: identity,
+          namespace: namespace,
+          workflow_type: Temporal::Api::Common::V1::WorkflowType.new(
+            name: workflow_name
+          ),
+          workflow_id: workflow_id,
+          task_queue: Temporal::Api::TaskQueue::V1::TaskQueue.new(
+            name: task_queue
+          ),
+          input: Serializer::Payload.new(input).to_proto,
+          workflow_execution_timeout: execution_timeout,
+          workflow_run_timeout: execution_timeout,
+          workflow_task_timeout: task_timeout,
+          request_id: SecureRandom.uuid,
+          header: Temporal::Api::Common::V1::Header.new(
+            fields: headers
+          )
+        )
+
+        if workflow_id_reuse_policy
+          policy = WORKFLOW_ID_REUSE_POLICY[workflow_id_reuse_policy]
+          raise Client::ArgumentError, 'Unknown workflow_id_reuse_policy specified' unless policy
+
+          request.workflow_id_reuse_policy = policy
+        end
+
+        client.start_workflow_execution(request)
+      rescue GRPC::AlreadyExists => e
+        # Feel like there should be cleaner way to do this...
+        run_id = e.details[/RunId: (.*)\.$/, 1]
+        raise Temporal::WorkflowExecutionAlreadyStartedFailure.new(e.details, run_id)
+      end
+
+      def get_workflow_execution_history(namespace:, workflow_id:, run_id:)
+        request = Temporal::Api::WorkflowService::V1::GetWorkflowExecutionHistoryRequest.new(
+          namespace: namespace,
+          execution: Temporal::Api::Common::V1::WorkflowExecution.new(
+            workflow_id: workflow_id,
+            run_id: run_id
+          )
+        )
+
+        client.get_workflow_execution_history(request)
+      end
+
+      def poll_workflow_task_queue(namespace:, task_queue:)
+        request = Temporal::Api::WorkflowService::V1::PollWorkflowTaskQueueRequest.new(
+          identity: identity,
+          namespace: namespace,
+          task_queue: Temporal::Api::TaskQueue::V1::TaskQueue.new(
+            name: task_queue
+          )
+        )
+        client.poll_workflow_task_queue(request)
+      end
+
+      def respond_workflow_task_completed(task_token:, commands:)
+        request = Temporal::Api::WorkflowService::V1::RespondWorkflowTaskCompletedRequest.new(
+          identity: identity,
+          task_token: task_token,
+          commands: Array(commands).map { |(_, command)| Serializer.serialize(command) }
+        )
+        client.respond_workflow_task_completed(request)
+      end
+
+      def respond_workflow_task_failed(task_token:, cause:, exception: nil)
+        request = Temporal::Api::WorkflowService::V1::RespondWorkflowTaskFailedRequest.new(
+          identity: identity,
+          task_token: task_token,
+          cause: cause,
+          failure: Serializer::Failure.new(exception).to_proto
+        )
+        client.respond_workflow_task_failed(request)
+      end
+
+      def poll_activity_task_queue(namespace:, task_queue:)
+        request = Temporal::Api::WorkflowService::V1::PollActivityTaskQueueRequest.new(
+          identity: identity,
+          namespace: namespace,
+          task_queue: Temporal::Api::TaskQueue::V1::TaskQueue.new(
+            name: task_queue
+          )
+        )
+        client.poll_activity_task_queue(request)
+      end
+
+      def record_activity_task_heartbeat(task_token:, details: nil)
+        request = Temporal::Api::WorkflowService::V1::RecordActivityTaskHeartbeatRequest.new(
+          task_token: task_token,
+          details: Serializer::Payload.new(details).to_proto,
+          identity: identity
+        )
+        client.record_activity_task_heartbeat(request)
+      end
+
+      def record_activity_task_heartbeat_by_id
+        raise NotImplementedError
+      end
+
+      def respond_activity_task_completed(task_token:, result:)
+        request = Temporal::Api::WorkflowService::V1::RespondActivityTaskCompletedRequest.new(
+          identity: identity,
+          task_token: task_token,
+          result: Serializer::Payload.new(result).to_proto,
+        )
+        client.respond_activity_task_completed(request)
+      end
+
+      def respond_activity_task_completed_by_id(namespace:, activity_id:, workflow_id:, run_id:, result:)
+        request = Temporal::Api::WorkflowService::V1::RespondActivityTaskCompletedByIdRequest.new(
+          identity: identity,
+          namespace: namespace,
+          workflow_id: workflow_id,
+          run_id: run_id,
+          activity_id: activity_id,
+          result: Serializer::Payload.new(result).to_proto
+        )
+        client.respond_activity_task_completed_by_id(request)
+      end
+
+      def respond_activity_task_failed(task_token:, exception:)
+        request = Temporal::Api::WorkflowService::V1::RespondActivityTaskFailedRequest.new(
+          identity: identity,
+          task_token: task_token,
+          failure: Serializer::Failure.new(exception).to_proto
+        )
+        client.respond_activity_task_failed(request)
+      end
+
+      def respond_activity_task_failed_by_id(namespace:, activity_id:, workflow_id:, run_id:, exception:)
+        request = Temporal::Api::WorkflowService::V1::RespondActivityTaskFailedByIdRequest.new(
+          identity: identity,
+          namespace: namespace,
+          workflow_id: workflow_id,
+          run_id: run_id,
+          activity_id: activity_id,
+          failure: Serializer::Failure.new(exception).to_proto
+        )
+        client.respond_activity_task_failed_by_id(request)
+      end
+
+      def respond_activity_task_canceled(task_token:, details: nil)
+        request = Temporal::Api::WorkflowService::V1::RespondActivityTaskCanceledRequest.new(
+          task_token: task_token,
+          details: Serializer::Payload.new(details).to_proto,
+          identity: identity
+        )
+        client.respond_activity_task_canceled(request)
+      end
+
+      def respond_activity_task_canceled_by_id
+        raise NotImplementedError
+      end
+
+      def request_cancel_workflow_execution
+        raise NotImplementedError
+      end
+
+      def signal_workflow_execution(namespace:, workflow_id:, run_id:, signal:, input: nil)
+        request = Temporal::Api::WorkflowService::V1::SignalWorkflowExecutionRequest.new(
+          namespace: namespace,
+          workflow_execution: Temporal::Api::Common::V1::WorkflowExecution.new(
+            workflow_id: workflow_id,
+            run_id: run_id
+          ),
+          signal_name: signal,
+          input: Serializer::Payload.new(input).to_proto,
+          identity: identity
+        )
+        client.signal_workflow_execution(request)
+      end
+
+      def signal_with_start_workflow_execution
+        raise NotImplementedError
+      end
+
+      def reset_workflow_execution(namespace:, workflow_id:, run_id:, reason:, workflow_task_event_id:)
+        request = Temporal::Api::WorkflowService::V1::ResetWorkflowExecutionRequest.new(
+          namespace: namespace,
+          workflow_execution: Temporal::Api::Common::V1::WorkflowExecution.new(
+            workflow_id: workflow_id,
+            run_id: run_id
+          ),
+          reason: reason,
+          workflow_task_finish_event_id: workflow_task_event_id
+        )
+        client.reset_workflow_execution(request)
+      end
+
+      def terminate_workflow_execution
+        raise NotImplementedError
+      end
+
+      def list_open_workflow_executions
+        raise NotImplementedError
+      end
+
+      def list_closed_workflow_executions
+        raise NotImplementedError
+      end
+
+      def list_workflow_executions
+        raise NotImplementedError
+      end
+
+      def list_archived_workflow_executions
+        raise NotImplementedError
+      end
+
+      def scan_workflow_executions
+        raise NotImplementedError
+      end
+
+      def count_workflow_executions
+        raise NotImplementedError
+      end
+
+      def get_search_attributes
+        raise NotImplementedError
+      end
+
+      def respond_query_task_completed
+        raise NotImplementedError
+      end
+
+      def reset_sticky_task_queue
+        raise NotImplementedError
+      end
+
+      def query_workflow
+        raise NotImplementedError
+      end
+
+      def describe_workflow_execution(namespace:, workflow_id:, run_id:)
+        request = Temporal::Api::WorkflowService::V1::DescribeWorkflowExecutionRequest.new(
+          namespace: namespace,
+          execution: Temporal::Api::Common::V1::WorkflowExecution.new(
+            workflow_id: workflow_id,
+            run_id: run_id
+          )
+        )
+        client.describe_workflow_execution(request)
+      end
+
+      def describe_task_queue(namespace:, task_queue:)
+        request = Temporal::Api::WorkflowService::V1::DescribeTaskQueueRequest.new(
+          namespace: namespace,
+          task_queue: Temporal::Api::TaskQueue::V1::TaskQueue.new(
+            name: task_queue
+          ),
+          task_queue_type: Temporal::Api::Enums::V1::TaskQueueType::Workflow,
+          include_task_queue_status: true
+        )
+        client.describe_task_queue(request)
+      end
+
+      private
+
+      attr_reader :url, :identity
+
+      def client
+        @client ||= Temporal::Api::WorkflowService::V1::WorkflowService::Stub.new(
+          url,
+          :this_channel_is_insecure,
+          timeout: 5
+        )
+      end
+    end
+  end
+end