temporalio 0.0.2 → 0.1.0

data/lib/temporalio/worker/activity_worker.rb

@@ -1,17 +1,32 @@
 require 'temporalio/error/failure'
 require 'temporalio/errors'
+require 'temporalio/interceptor'
+require 'temporalio/interceptor/chain'
 require 'temporalio/worker/activity_runner'
-require 'temporalio/worker/sync_worker'
 
 module Temporalio
   class Worker
     # @api private
     class ActivityWorker
-      def initialize(task_queue, core_worker, activities, converter, executor, graceful_timeout)
+      def initialize(
+        task_queue,
+        worker,
+        activities,
+        converter,
+        interceptors,
+        executor,
+        graceful_timeout
+      )
         @task_queue = task_queue
-        @worker = SyncWorker.new(core_worker)
+        @worker = worker
         @activities = prepare_activities(activities)
         @converter = converter
+        @inbound_interceptors = Temporalio::Interceptor::Chain.new(
+          Temporalio::Interceptor.filter(interceptors, :activity_inbound),
+        )
+        @outbound_interceptors = Temporalio::Interceptor::Chain.new(
+          Temporalio::Interceptor.filter(interceptors, :activity_outbound),
+        )
         @executor = executor
         @graceful_timeout = graceful_timeout
         @running_activities = {}
@@ -38,20 +53,21 @@ module Temporalio
       rescue Temporalio::Bridge::Error::WorkerShutdown
         # No need to re-raise this error, it's a part of a normal shutdown
       ensure
-        reactor.async do |async_task|
-          cancelation_task =
-            if graceful_timeout
-              async_task.async do
-                sleep graceful_timeout
-                running_activities.each_value do |activity_runner|
-                  activity_runner.cancel('Worker is shutting down', by_request: false)
-                end
+        outstanding_tasks.each(&:wait)
+        @cancelation_task&.wait
+        drain_queue.close
+      end
+
+      def setup_graceful_shutdown_timer(reactor)
+        if graceful_timeout
+          reactor.async do |async_task|
+            @cancelation_task = async_task.async do
+              sleep graceful_timeout
+              @running_activities.each_value do |activity_runner|
+                activity_runner.cancel('Worker is shutting down', by_request: false)
               end
             end
-
-          outstanding_tasks.each(&:wait)
-          cancelation_task&.stop # all tasks completed, stop cancellations
-          drain_queue.close
+          end
         end
       end
 
@@ -61,8 +77,9 @@ module Temporalio
 
       private
 
-      attr_reader :task_queue, :worker, :activities, :converter, :executor, :graceful_timeout,
-                  :running_activities, :cancellations, :drain_queue
+      attr_reader :task_queue, :worker, :activities, :converter, :inbound_interceptors,
+                  :outbound_interceptors, :executor, :graceful_timeout, :running_activities,
+                  :cancellations, :drain_queue
 
       def prepare_activities(activities)
         activities.each_with_object({}) do |activity, result|
@@ -91,7 +108,16 @@ module Temporalio
 
       def run_activity(token, start)
         activity_class = lookup_activity(start.activity_type)
-        runner = ActivityRunner.new(activity_class, start, task_queue, token, worker, converter)
+        runner = ActivityRunner.new(
+          activity_class,
+          start,
+          task_queue,
+          token,
+          worker,
+          converter,
+          inbound_interceptors,
+          outbound_interceptors,
+        )
         running_activities[token] = runner
         queue = Queue.new
 

data/lib/temporalio/worker/sync_worker.rb

@@ -1,5 +1,7 @@
 require 'temporal/sdk/core/activity_task/activity_task_pb'
 require 'temporal/sdk/core/core_interface_pb'
+require 'temporal/sdk/core/workflow_activation/workflow_activation_pb'
+require 'temporal/sdk/core/workflow_completion/workflow_completion_pb'
 
 module Temporalio
   class Worker
@@ -19,45 +21,71 @@ module Temporalio
       def poll_activity_task
         with_queue do |done|
           core_worker.poll_activity_task do |task, error|
-            done.call(task && Coresdk::ActivityTask::ActivityTask.decode(task), error)
+            done.call(task && Temporalio::Bridge::Api::ActivityTask::ActivityTask.decode(task), error)
           end
         end
       end
 
       def complete_activity_task_with_success(task_token, payload)
-        result = Coresdk::ActivityResult::ActivityExecutionResult.new(
-          completed: Coresdk::ActivityResult::Success.new(result: payload),
+        result = Temporalio::Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+          completed: Temporalio::Bridge::Api::ActivityResult::Success.new(result: payload),
         )
 
         complete_activity_task(task_token, result)
       end
 
       def complete_activity_task_with_failure(task_token, failure)
-        result = Coresdk::ActivityResult::ActivityExecutionResult.new(
-          failed: Coresdk::ActivityResult::Failure.new(failure: failure),
+        result = Temporalio::Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+          failed: Temporalio::Bridge::Api::ActivityResult::Failure.new(failure: failure),
         )
 
         complete_activity_task(task_token, result)
       end
 
       def complete_activity_task_with_cancellation(task_token, failure)
-        result = Coresdk::ActivityResult::ActivityExecutionResult.new(
-          cancelled: Coresdk::ActivityResult::Cancellation.new(failure: failure),
+        result = Temporalio::Bridge::Api::ActivityResult::ActivityExecutionResult.new(
+          cancelled: Temporalio::Bridge::Api::ActivityResult::Cancellation.new(failure: failure),
         )
 
         complete_activity_task(task_token, result)
       end
 
       def record_activity_heartbeat(task_token, payloads)
-        proto = Coresdk::ActivityHeartbeat.new(
+        proto = Temporalio::Bridge::Api::CoreInterface::ActivityHeartbeat.new(
           task_token: task_token,
           details: payloads,
         )
-        encoded_proto = Coresdk::ActivityHeartbeat.encode(proto)
+        encoded_proto = Temporalio::Bridge::Api::CoreInterface::ActivityHeartbeat.encode(proto)
 
         core_worker.record_activity_heartbeat(encoded_proto)
       end
 
+      def poll_workflow_activation
+        with_queue do |done|
+          core_worker.poll_workflow_activation do |task, error|
+            done.call(task && Temporalio::Bridge::Api::WorkflowActivation::WorkflowActivation.decode(task), error)
+          end
+        end
+      end
+
+      def complete_workflow_activation_with_success(run_id, commands)
+        proto = Temporalio::Bridge::Api::WorkflowCompletion::WorkflowActivationCompletion.new(
+          run_id: run_id,
+          successful: Temporalio::Bridge::Api::WorkflowCompletion::Success.new(commands: commands),
+        )
+
+        complete_workflow_activation(proto)
+      end
+
+      def complete_workflow_activation_with_failure(run_id, failure)
+        proto = Temporalio::Bridge::Api::WorkflowCompletion::WorkflowActivationCompletion.new(
+          run_id: run_id,
+          failed: Temporalio::Bridge::Api::WorkflowCompletion::Failure.new(failure: failure),
+        )
+
+        complete_workflow_activation(proto)
+      end
+
       private
 
       attr_reader :core_worker
@@ -73,16 +101,24 @@ module Temporalio
       end
 
       def complete_activity_task(task_token, result)
-        proto = Coresdk::ActivityTaskCompletion.new(
+        proto = Temporalio::Bridge::Api::CoreInterface::ActivityTaskCompletion.new(
           task_token: task_token,
           result: result,
         )
-        encoded_proto = Coresdk::ActivityTaskCompletion.encode(proto)
+        encoded_proto = Temporalio::Bridge::Api::CoreInterface::ActivityTaskCompletion.encode(proto)
 
         with_queue do |done|
           core_worker.complete_activity_task(encoded_proto, &done)
         end
       end
+
+      def complete_workflow_activation(proto)
+        encoded_proto = Temporalio::Bridge::Api::WorkflowCompletion::WorkflowActivationCompletion.encode(proto)
+
+        with_queue do |done|
+          core_worker.complete_workflow_activation(encoded_proto, &done)
+        end
+      end
     end
   end
 end

data/lib/temporalio/worker.rb

@@ -4,10 +4,11 @@ require 'temporalio/data_converter'
 require 'temporalio/runtime'
 require 'temporalio/worker/activity_worker'
 require 'temporalio/worker/runner'
+require 'temporalio/worker/sync_worker'
 require 'temporalio/worker/thread_pool_executor'
 
 module Temporalio
-  # Worker to process workflows and/or activities.
+  # Worker to process activities.
   #
   # Once created, workers can be run and shutdown explicitly via {#run} and {#shutdown}.
   class Worker
@@ -40,7 +41,7 @@ module Temporalio
       Runner.new(*workers).run(&block)
     end
 
-    # Create a worker to process workflows and/or activities.
+    # Create a worker to process activities.
     #
     # @param connection [Temporalio::Connection] A connection to be used for this worker.
     # @param namespace [String] A namespace.
@@ -50,12 +51,14 @@ module Temporalio
     #   to/from payloads.
     # @param activity_executor [ThreadPoolExecutor] Concurrent executor for all activities. Defaults
     #   to a {ThreadPoolExecutor} with `:max_concurrent_activities` available threads.
+    # @param interceptors [Array<Temporalio::Interceptor::ActivityInbound, Temporalio::Interceptor::ActivityOutbound>]
+    #   Collection of interceptors for this worker.
     # @param max_concurrent_activities [Integer] Number of concurrently running activities.
     # @param graceful_shutdown_timeout [Integer] Amount of time (in seconds) activities are given
     #   after a shutdown to complete before they are cancelled. A default value of `nil` means that
     #   activities are never cancelled when handling a shutdown.
     #
-    # @raise [ArgumentError] When no activities or workflows have been provided.
+    # @raise [ArgumentError] When no activities have been provided.
     def initialize(
       connection,
       namespace,
@@ -63,10 +66,10 @@ module Temporalio
       activities: [],
       data_converter: Temporalio::DataConverter.new,
       activity_executor: nil,
+      interceptors: [],
       max_concurrent_activities: 100,
       graceful_shutdown_timeout: nil
     )
-      # TODO: Add worker interceptors
       @started = false
       @shutdown = false
       @mutex = Mutex.new
@@ -77,22 +80,26 @@ module Temporalio
         connection.core_connection,
         namespace,
         task_queue,
+        0, # maxCachedWorkflows disabled temporarily
+        # FIXME: expose enable_non_local_activities
+        activities.empty?,
       )
+      sync_worker = Worker::SyncWorker.new(@core_worker)
       @activity_worker =
         unless activities.empty?
           Worker::ActivityWorker.new(
             task_queue,
-            @core_worker,
+            sync_worker,
             activities,
             data_converter,
+            interceptors,
             @activity_executor,
             graceful_shutdown_timeout,
           )
         end
-      @workflow_worker = nil
 
-      if !@activity_worker && !@workflow_worker
-        raise ArgumentError, 'At least one activity or workflow must be specified'
+      unless @activity_worker
+        raise ArgumentError, 'At least one activity must be specified'
       end
     end
 
@@ -105,9 +112,9 @@ module Temporalio
     #   run it again.
     #
     # @yield Optionally you can provide a block by the end of which the worker will shut itself
-    #   down. You can use this to stop a worker after some time has passed, your workflow has
-    #   finished or any other arbitrary implementation has completed. Any errors raised from this
-    #   block will be re-raised by this method.
+    #   down. You can use this to stop a worker after some time has passed or any other arbitrary
+    #   implementation has completed. Any errors raised from this block will be re-raised by this
+    #   method.
     def run(&block)
       Runner.new(self).run(&block)
     end
@@ -141,9 +148,6 @@ module Temporalio
             shutdown(e) # initiate shutdown because of a fatal error
           end
         end
-
-        # TODO: Pending implementation
-        task.async { |task| workflow_worker.run(task) } if workflow_worker
       end
     end
 
@@ -158,17 +162,19 @@ module Temporalio
       mutex.synchronize do
         return unless running?
 
-        # First initiate Core shutdown, which will start dropping poll requests
-        core_worker.initiate_shutdown
-        # Then let the runner know we're shutting down, so it can stop other workers
+        # Let the runner know we're shutting down, so it can stop other workers.
+        # This will cause a reentrant call to this method, but the mutex above will block that call.
         runner&.shutdown(exception)
+
+        # Initiate Core shutdown, which will start dropping poll requests
+        core_worker.initiate_shutdown
+        # Start the graceful activity shutdown timer, which will cancel activities after the timeout
+        activity_worker&.setup_graceful_shutdown_timer(runtime.reactor)
         # Wait for workers to drain any outstanding tasks
         activity_worker&.drain
-        workflow_worker&.drain
-        # Stop the executor (at this point there should already be nothing in it)
         activity_executor.shutdown
         # Finalize the shutdown by stopping the Core
-        core_worker.shutdown
+        core_worker.finalize_shutdown
 
         @shutdown = true
       end
@@ -193,6 +199,6 @@ module Temporalio
     private
 
     attr_reader :mutex, :runtime, :activity_executor, :core_worker, :activity_worker,
-                :workflow_worker, :runner
+                :runner
   end
 end

data/lib/temporalio/workflow/async.rb

@@ -0,0 +1,46 @@
+require 'temporalio/workflow/future'
+
+module Temporalio
+  class Workflow
+    module Async
+      def self.run(&block)
+        Future.new do |future, resolve, reject|
+          Fiber.new do
+            Future.current = future
+            result = block.call
+            resolve.call(result)
+          rescue StandardError => e
+            reject.call(e)
+          end.resume
+        end
+      end
+
+      def self.all(*futures)
+        Future.new do |future, resolve, _reject|
+          future.on_cancel { futures.each(&:cancel) }
+
+          futures.each do |f|
+            f.then do
+              # Resolve the aggregate once all futures have been fulfilled (resolved or rejected)
+              resolve.call(nil) if futures.none?(&:pending?)
+            end
+          end
+        end
+      end
+
+      def self.any(*futures)
+        # This future is never rejected
+        Future.new do |future, resolve, _reject|
+          future.on_cancel { futures.each(&:cancel) }
+
+          futures.each do |f|
+            # Resolve the aggregate once the first future fulfills (resolved or rejected)
+            # NOTE: The the first completed future will be the resolved value and all subsequent
+            #       calls to `resolve` will have no effect.
+            f.then { resolve.call(f) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/workflow/future.rb

@@ -0,0 +1,138 @@
+module Temporalio
+  class Workflow
+    class Future
+      THREAD_KEY = :temporalio_workflow_future
+
+      class Rejected < StandardError; end
+
+      def self.current
+        Thread.current[THREAD_KEY]
+      end
+
+      def self.current=(future)
+        Thread.current[THREAD_KEY] = future
+      end
+
+      # Revist the reason for combining futures and cancellation scopes, maybe they are separate?
+      def initialize(&block)
+        @resolved = false
+        @value = nil
+        @rejected = false
+        @error = Rejected.new('Future rejected')
+        @cancel_requested = false
+        @blocked_fibers = []
+        @callbacks = []
+        @cancel_callbacks = []
+
+        # Chain cancellation into parent future if one exists
+        Future.current&.on_cancel { cancel }
+
+        # NOTE: resolve and reject methods are accessible via procs to avoid exposing
+        #       them via the public interface.
+        block.call(
+          self,
+          ->(value) { resolve(value) },
+          ->(error) { reject(error) },
+        )
+      end
+
+      def then(&block)
+        Future.new do |future, resolve, reject|
+          # @type var wrapped_block: ^() -> void
+          wrapped_block = -> do # rubocop:disable Style/Lambda
+            Fiber.new do
+              Future.current = future
+              # The block is provided the Future on which #then was called
+              result = block.call(self)
+              resolve.call(result)
+            rescue StandardError => e
+              reject.call(e)
+            end.resume
+          end
+
+          if pending?
+            callbacks << wrapped_block
+          else
+            wrapped_block.call
+          end
+        end
+      end
+
+      def on_cancel(&block)
+        if pending? && !cancel_requested?
+          cancel_callbacks << block
+        else
+          block.call
+        end
+      end
+
+      def pending?
+        !resolved? && !rejected?
+      end
+
+      def resolved?
+        @resolved
+      end
+
+      def rejected?
+        @rejected
+      end
+
+      def await
+        if pending?
+          blocked_fibers << Fiber.current
+          # yield into the parent fiber
+          Fiber.yield while pending?
+        end
+
+        raise error if rejected?
+
+        value
+      end
+
+      def cancel
+        return unless pending?
+        return if cancel_requested?
+
+        @cancel_requested = true
+        cancel_callbacks.each(&:call)
+      end
+
+      private
+
+      attr_reader :value, :error, :blocked_fibers, :callbacks, :cancel_callbacks
+
+      def cancel_requested?
+        @cancel_requested
+      end
+
+      # TODO: Run callbacks in a Fiber to allow blocking calls
+      def run_callbacks
+        callbacks.each(&:call)
+      end
+
+      # Unblock every fiber that this future is awaited on
+      def resume_fibers
+        blocked_fibers.each(&:resume)
+      end
+
+      def resolve(value)
+        return unless pending?
+
+        @value = value
+        @resolved = true
+        run_callbacks
+        resume_fibers
+      end
+
+      def reject(error)
+        return unless pending?
+
+        @error = error
+        @rejected = true
+        run_callbacks
+        resume_fibers
+      end
+    end
+  end
+end

data/lib/temporalio/workflow/info.rb

@@ -0,0 +1,76 @@
+module Temporalio
+  class Workflow
+    # Class containing information about a workflow's parent.
+    class ParentInfo < Struct.new(
+      :namespace,
+      :run_id,
+      :workflow_id,
+      keyword_init: true,
+    )
+      # @!attribute [r] namespace
+      #   @return [String] Namespace of the parent workflow.
+      # @!attribute [r] run_id
+      #   @return [String] Run ID of the parent workflow.
+      # @!attribute [r] workflow_id
+      #   @return [String] ID of the parent workflow.
+    end
+
+    # Class containing information about a workflow.
+    class Info < Struct.new(
+      :attempt,
+      :continued_run_id,
+      :cron_schedule,
+      :execution_timeout,
+      :headers,
+      :namespace,
+      :parent,
+      :raw_memo,
+      :retry_policy,
+      :run_id,
+      :run_timeout,
+      :search_attributes,
+      :start_time,
+      :task_queue,
+      :task_timeout,
+      :workflow_id,
+      :workflow_type,
+      keyword_init: true,
+    )
+      # @!attribute [r] attempt
+      #   @return [Integer] Attempt of executing the workflow.
+      # @!attribute [r] continued_run_id
+      #   @return [String] Run id of the previous workflow which continued-as-new or retired or cron
+      #     executed into this workflow, if any.
+      # @!attribute [r] cron_schedule
+      #   @return [String] Cron schedule of the workflow.
+      # @!attribute [r] execution_timeout
+      #   @return [Float] Execution timeout of the workflow (in seconds).
+      # @!attribute [r] headers
+      #   @return [Hash<String, any>] Headers for the workflow.
+      # @!attribute [r] namespace
+      #   @return [String] Namespace of the workflow.
+      # @!attribute [r] parent
+      #   @return [Temporalio::Workflow::ParentInfo] Info of the parent workflow.
+      # @!attribute [r] raw_memo
+      #   @return [Hash<String, any>] Memo for the workflow.
+      # @!attribute [r] retry_policy
+      #   @return [Temporalio::RetryPolicy] RetryPolicy of the workflow.
+      # @!attribute [r] run_id
+      #   @return [String] Run ID of the workflow.
+      # @!attribute [r] run_timeout
+      #   @return [Float] Run timeout of the workflow (in seconds).
+      # @!attribute [r] search_attributes
+      #   @return [Hash<String, String>] Search attributes of the workflow.
+      # @!attribute [r] start_time
+      #   @return [Time] Start time of the workflow.
+      # @!attribute [r] task_queue
+      #   @return [String] Task queue of the workflow.
+      # @!attribute [r] task_timeout
+      #   @return [Float] Task timeout of the workflow (in seconds).
+      # @!attribute [r] workflow_id
+      #   @return [String] ID of the workflow.
+      # @!attribute [r] workflow_type
+      #   @return [String] Type of the workflow.
+    end
+  end
+end

data/temporalio.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/temporalio/sdk-ruby'
   spec.licenses      = ['MIT']
 
-  spec.authors       = ['Anthony D']
-  spec.email         = ['anthony@temporal.io']
+  spec.authors       = ['Temporal Technologies Inc.']
+  spec.email         = ['sdk@temporal.io']
 
   spec.require_paths = ['lib']
   spec.extensions    = ['ext/Rakefile']
@@ -35,11 +35,12 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'protobuf' # Ruby implementation of protobufs (for rbs_protobuf)
   spec.add_development_dependency 'pry' # Debugger
   spec.add_development_dependency 'rake' # rake tasks
+  spec.add_development_dependency 'rbs', '>= 2.8.0', '< 3.0.0' # RBS - steep 1.3.0 crashes with RBS 3.0.0
   spec.add_development_dependency 'rbs_protobuf' # RBS generator for protobufs
   spec.add_development_dependency 'rspec' # specs
   spec.add_development_dependency 'rubocop' # linter
   spec.add_development_dependency 'rubocop-rspec' # spec linter
-  spec.add_development_dependency 'steep' # type checker
+  spec.add_development_dependency 'steep', '~> 1.3.0' # type checker
   spec.add_development_dependency 'typeprof' # type generator
   spec.add_development_dependency 'yard' # docs
 end