temporal-ruby 0.0.1.pre.pre1 → 0.0.1

data/lib/temporal/testing/temporal_override.rb

@@ -7,11 +7,25 @@ require 'temporal/testing/local_workflow_context'
 module Temporal
   module Testing
     module TemporalOverride
+
       def start_workflow(workflow, *input, **args)
         return super if Temporal::Testing.disabled?
 
         if Temporal::Testing.local?
-          start_locally(workflow, *input, **args)
+          start_locally(workflow, nil, *input, **args)
+        end
+      end
+
+      # We don't support testing the actual cron schedules, but we will defer
+      # execution.  You can simulate running these deferred with
+      # Temporal::Testing.execute_all_scheduled_workflows o
+      # Temporal::Testing.execute_scheduled_workflow, or assert against the cron schedule with
+      # Temporal::Testing.schedules.
+      def schedule_workflow(workflow, cron_schedule, *input, **args)
+        return super if Temporal::Testing.disabled?
+
+        if Temporal::Testing.local?
+          start_locally(workflow, cron_schedule, *input, **args)
         end
       end
 
@@ -55,7 +69,7 @@ module Temporal
         @executions ||= {}
       end
 
-      def start_locally(workflow, *input, **args)
+      def start_locally(workflow, schedule, *input, **args)
         options = args.delete(:options) || {}
         input << args unless args.empty?
 
@@ -74,15 +88,29 @@ module Temporal
         executions[[workflow_id, run_id]] = execution
 
         execution_options = ExecutionOptions.new(workflow, options)
-        headers = execution_options.headers
+        metadata = Metadata::Workflow.new(
+          name: workflow_id, run_id: run_id, attempt: 1, headers: execution_options.headers
+        )
         context = Temporal::Testing::LocalWorkflowContext.new(
-          execution, workflow_id, run_id, workflow.disabled_releases, headers
+          execution, workflow_id, run_id, workflow.disabled_releases, metadata
         )
 
-        execution.run do
-          workflow.execute_in_context(context, input)
+        if schedule.nil?
+          execution.run do
+            workflow.execute_in_context(context, input)
+          end
+        else
+          # Defer execution; in testing mode, it'll need to be invoked manually.
+          Temporal::Testing::ScheduledWorkflows::Private::Store.add(
+            workflow_id: workflow_id,
+            cron_schedule: schedule,
+            executor_lambda: lambda do
+              execution.run do
+                workflow.execute_in_context(context, input)
+              end
+            end,
+          )
         end
-
         run_id
       end
 

data/lib/temporal/testing/workflow_override.rb

@@ -1,6 +1,8 @@
 require 'securerandom'
+require 'set'
 require 'temporal/testing/local_workflow_context'
 require 'temporal/testing/workflow_execution'
+require 'temporal/metadata/workflow'
 
 module Temporal
   module Testing
@@ -25,8 +27,11 @@ module Temporal
         workflow_id = SecureRandom.uuid
         run_id = SecureRandom.uuid
         execution = WorkflowExecution.new
+        metadata = Temporal::Metadata::Workflow.new(
+          name: workflow_id, run_id: run_id, attempt: 1
+        )
         context = Temporal::Testing::LocalWorkflowContext.new(
-          execution, workflow_id, run_id, disabled_releases
+          execution, workflow_id, run_id, disabled_releases, metadata
         )
 
         execute_in_context(context, input)

data/lib/temporal/version.rb

@@ -1,3 +1,3 @@
 module Temporal
-  VERSION = '0.0.1-pre1'.freeze
+  VERSION = '0.0.1'.freeze
 end

data/lib/temporal/worker.rb

@@ -7,13 +7,24 @@ require 'temporal/middleware/entry'
 
 module Temporal
   class Worker
-    def initialize
+    # activity_thread_pool_size: number of threads that the poller can use to run activities.
+    #   can be set to 1 if you want no paralellism in your activities, at the cost of throughput.
+    def initialize(
+      activity_thread_pool_size: Temporal::Activity::Poller::DEFAULT_OPTIONS[:thread_pool_size],
+      workflow_thread_pool_size: Temporal::Workflow::Poller::DEFAULT_OPTIONS[:thread_pool_size]
+    )
       @workflows = Hash.new { |hash, key| hash[key] = ExecutableLookup.new }
       @activities = Hash.new { |hash, key| hash[key] = ExecutableLookup.new }
       @pollers = []
       @workflow_task_middleware = []
       @activity_middleware = []
       @shutting_down = false
+      @activity_poller_options = {
+        thread_pool_size: activity_thread_pool_size,
+      }
+      @workflow_poller_options = {
+        thread_pool_size: workflow_thread_pool_size,
+      }
     end
 
     def register_workflow(workflow_class, options = {})
@@ -51,32 +62,39 @@ module Temporal
 
       pollers.each(&:start)
 
-      # wait until instructed to shut down
-      while !shutting_down? do
-        sleep 1
-      end
+      # keep the main thread alive
+      sleep 1 while !shutting_down?
     end
 
     def stop
       @shutting_down = true
-      pollers.each(&:stop)
-      pollers.each(&:wait)
+
+      Thread.new do
+        pollers.each(&:stop_polling)
+        # allow workers to drain in-transit tasks.
+        # https://github.com/temporalio/temporal/issues/1058
+        sleep 1
+        pollers.each(&:cancel_pending_requests)
+        pollers.each(&:wait)
+      end.join
     end
 
     private
 
-    attr_reader :activities, :workflows, :pollers, :workflow_task_middleware, :activity_middleware
+    attr_reader :activity_poller_options, :workflow_poller_options,
+                :activities, :workflows, :pollers,
+                :workflow_task_middleware, :activity_middleware
 
     def shutting_down?
       @shutting_down
     end
 
     def workflow_poller_for(namespace, task_queue, lookup)
-      Workflow::Poller.new(namespace, task_queue, lookup.freeze, workflow_task_middleware)
+      Workflow::Poller.new(namespace, task_queue, lookup.freeze, workflow_task_middleware, workflow_poller_options)
     end
 
     def activity_poller_for(namespace, task_queue, lookup)
-      Activity::Poller.new(namespace, task_queue, lookup.freeze, activity_middleware)
+      Activity::Poller.new(namespace, task_queue, lookup.freeze, activity_middleware, activity_poller_options)
     end
 
     def trap_signals

data/lib/temporal/workflow.rb

@@ -1,6 +1,7 @@
 require 'temporal/concerns/executable'
 require 'temporal/workflow/convenience_methods'
 require 'temporal/thread_local_context'
+require 'temporal/error_handler'
 
 module Temporal
   class Workflow
@@ -8,17 +9,22 @@ module Temporal
     extend ConvenienceMethods
 
     def self.execute_in_context(context, input)
+      old_context = Temporal::ThreadLocalContext.get
       Temporal::ThreadLocalContext.set(context)
 
       workflow = new(context)
       result = workflow.execute(*input)
 
-      context.complete(result)
+      context.complete(result) unless context.completed?
     rescue StandardError, ScriptError => error
-      Temporal.logger.error("Workflow execution failed with: #{error.inspect}")
+      Temporal.logger.error("Workflow execution failed", context.metadata.to_h.merge(error: error.inspect))
       Temporal.logger.debug(error.backtrace.join("\n"))
 
+      Temporal::ErrorHandler.handle(error, metadata: context.metadata)
+
       context.fail(error)
+    ensure
+      Temporal::ThreadLocalContext.set(old_context)
     end
 
     def initialize(context)

data/lib/temporal/workflow/command.rb

@@ -4,6 +4,7 @@ module Temporal
       # TODO: Move these classes into their own directories under workflow/command/*
       ScheduleActivity = Struct.new(:activity_type, :activity_id, :input, :namespace, :task_queue, :retry_policy, :timeouts, :headers, keyword_init: true)
       StartChildWorkflow = Struct.new(:workflow_type, :workflow_id, :input, :namespace, :task_queue, :retry_policy, :timeouts, :headers, keyword_init: true)
+      ContinueAsNew = Struct.new(:workflow_type, :task_queue, :input, :timeouts, :retry_policy, :headers, keyword_init: true)
       RequestActivityCancellation = Struct.new(:activity_id, keyword_init: true)
       RecordMarker = Struct.new(:name, :details, keyword_init: true)
       StartTimer = Struct.new(:timeout, :timer_id, keyword_init: true)
@@ -14,6 +15,7 @@ module Temporal
       # only these commands are supported right now
       SCHEDULE_ACTIVITY_TYPE = :schedule_activity
       START_CHILD_WORKFLOW_TYPE = :start_child_workflow
+      CONTINUE_AS_NEW = :continue_as_new
       RECORD_MARKER_TYPE = :record_marker
       START_TIMER_TYPE = :start_timer
       CANCEL_TIMER_TYPE = :cancel_timer
@@ -23,6 +25,7 @@ module Temporal
       COMMAND_CLASS_MAP = {
         SCHEDULE_ACTIVITY_TYPE => ScheduleActivity,
         START_CHILD_WORKFLOW_TYPE => StartChildWorkflow,
+        CONTINUE_AS_NEW => ContinueAsNew,
         RECORD_MARKER_TYPE => RecordMarker,
         START_TIMER_TYPE => StartTimer,
         CANCEL_TIMER_TYPE => CancelTimer,

data/lib/temporal/workflow/context.rb

@@ -15,10 +15,18 @@ require 'temporal/workflow/state_manager'
 module Temporal
   class Workflow
     class Context
-      def initialize(state_manager, dispatcher, metadata)
+      attr_reader :metadata
+
+      def initialize(state_manager, dispatcher, workflow_class, metadata)
         @state_manager = state_manager
         @dispatcher = dispatcher
+        @workflow_class = workflow_class
         @metadata = metadata
+        @completed = false
+      end
+
+      def completed?
+        @completed
       end
 
       def logger
@@ -57,11 +65,12 @@ module Temporal
 
         dispatcher.register_handler(target, 'completed') do |result|
           future.set(result)
-          future.callbacks.each { |callback| call_in_fiber(callback, result) }
+          future.success_callbacks.each { |callback| call_in_fiber(callback, result) }
         end
 
         dispatcher.register_handler(target, 'failed') do |exception|
           future.fail(exception)
+          future.failure_callbacks.each { |callback| call_in_fiber(callback, exception) }
         end
 
         future
@@ -109,11 +118,12 @@ module Temporal
 
         dispatcher.register_handler(target, 'completed') do |result|
           future.set(result)
-          future.callbacks.each { |callback| call_in_fiber(callback, result) }
+          future.success_callbacks.each { |callback| call_in_fiber(callback, result) }
         end
 
         dispatcher.register_handler(target, 'failed') do |exception|
           future.fail(exception)
+          future.failure_callbacks.each { |callback| call_in_fiber(callback, exception) }
         end
 
         future
@@ -150,11 +160,12 @@ module Temporal
 
         dispatcher.register_handler(target, 'fired') do |result|
           future.set(result)
-          future.callbacks.each { |callback| call_in_fiber(callback, result) }
+          future.success_callbacks.each { |callback| call_in_fiber(callback, result) }
         end
 
         dispatcher.register_handler(target, 'canceled') do |exception|
           future.fail(exception)
+          future.failure_callbacks.each { |callback| call_in_fiber(callback, exception) }
         end
 
         future
@@ -169,12 +180,32 @@ module Temporal
       def complete(result = nil)
         command = Command::CompleteWorkflow.new(result: result)
         schedule_command(command)
+        completed!
       end
 
       # TODO: check if workflow can be failed
       def fail(exception)
         command = Command::FailWorkflow.new(exception: exception)
         schedule_command(command)
+        completed!
+      end
+
+      def continue_as_new(*input, **args)
+        options = args.delete(:options) || {}
+        input << args unless args.empty?
+
+        execution_options = ExecutionOptions.new(workflow_class, options)
+
+        command = Command::ContinueAsNew.new(
+          workflow_type: execution_options.name,
+          task_queue: execution_options.task_queue,
+          input: input,
+          timeouts: execution_options.timeouts,
+          retry_policy: execution_options.retry_policy,
+          headers: execution_options.headers
+        )
+        schedule_command(command)
+        completed!
       end
 
       def wait_for_all(*futures)
@@ -226,7 +257,11 @@ module Temporal
 
       private
 
-      attr_reader :state_manager, :dispatcher, :metadata
+      attr_reader :state_manager, :dispatcher, :workflow_class
+
+      def completed!
+        @completed = true
+      end
 
       def schedule_command(command)
         state_manager.schedule(command)

data/lib/temporal/workflow/errors.rb

@@ -0,0 +1,39 @@
+require 'temporal/errors'
+
+module Temporal
+  class Workflow
+    class Errors
+      extend Concerns::Payloads
+
+      # Convert a failure returned from the server to an Error to raise to the client
+      # failure: Temporal::Api::Failure::V1::Failure
+      def self.generate_error(failure, default_exception_class = StandardError)
+        case failure.failure_info
+        when :application_failure_info
+          exception_class = safe_constantize(failure.application_failure_info.type)
+          exception_class ||= default_exception_class
+          message = from_details_payloads(failure.application_failure_info.details)
+          backtrace = failure.stack_trace.split("\n")
+
+          exception_class.new(message).tap do |exception|
+            exception.set_backtrace(backtrace) if !backtrace.empty?
+          end
+        when :timeout_failure_info
+          TimeoutError.new("Timeout type: #{failure.timeout_failure_info.timeout_type.to_s}")
+        when :canceled_failure_info
+          # TODO: Distinguish between different entity cancellations
+          StandardError.new(from_payloads(failure.canceled_failure_info.details))
+        else
+          StandardError.new(failure.message)
+        end
+      end
+
+      private_class_method def self.safe_constantize(const)
+        Object.const_get(const) if Object.const_defined?(const)
+      rescue NameError
+        nil
+      end
+
+    end
+  end
+end

data/lib/temporal/workflow/executor.rb

@@ -34,7 +34,7 @@ module Temporal
       attr_reader :workflow_class, :dispatcher, :state_manager, :history
 
       def execute_workflow(input, metadata)
-        context = Workflow::Context.new(state_manager, dispatcher, metadata)
+        context = Workflow::Context.new(state_manager, dispatcher, workflow_class, metadata)
 
         Fiber.new do
           workflow_class.execute_in_context(context, input)

data/lib/temporal/workflow/future.rb

@@ -3,13 +3,14 @@ require 'fiber'
 module Temporal
   class Workflow
     class Future
-      attr_reader :target, :callbacks
+      attr_reader :target, :success_callbacks, :failure_callbacks
 
       def initialize(target, context, cancelation_id: nil)
         @target = target
         @context = context
         @cancelation_id = cancelation_id
-        @callbacks = []
+        @success_callbacks = []
+        @failure_callbacks = []
         @ready = false
         @failed = false
         @result = nil
@@ -52,14 +53,25 @@ module Temporal
         @failed = true
       end
 
+      # When the activity completes successfully, the block will be called with any result
       def done(&block)
-        # do nothing
-        return if failed?
-
         if ready?
           block.call(result)
         else
-          callbacks << block
+          # If the future is still outstanding, schedule a callback for invocation by the
+          # workflow context when the workflow or activity is finished
+          success_callbacks << block
+        end
+      end
+
+      # When the activity fails, the block will be called with the exception
+      def failed(&block)
+        if failed?
+          block.call(exception)
+        else
+          # If the future is still outstanding, schedule a callback for invocation by the
+          # workflow context when the workflow or activity is finished
+          failure_callbacks << block
         end
       end
 

data/lib/temporal/workflow/history/event.rb

@@ -10,8 +10,6 @@ module Temporal
           ACTIVITY_TASK_CANCELED
           TIMER_FIRED
           REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED
-          WORKFLOW_EXECUTION_SIGNALED
-          WORKFLOW_EXECUTION_TERMINATED
           SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED
           EXTERNAL_WORKFLOW_EXECUTION_CANCEL_REQUESTED
           EXTERNAL_WORKFLOW_EXECUTION_SIGNALED
@@ -46,7 +44,7 @@ module Temporal
           case type
           when 'TIMER_FIRED'
             attributes.started_event_id
-          when 'WORKFLOW_EXECUTION_SIGNALED'
+          when 'WORKFLOW_EXECUTION_SIGNALED', 'WORKFLOW_EXECUTION_TERMINATED'
             1 # fixed id for everything related to current workflow
           when *EVENT_TYPES
             attributes.scheduled_event_id