temporalio 0.1.1 → 0.3.0

data/Rakefile

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/MissingCopEnableDirective, Style/DocumentationMethod
+
+require 'bundler/gem_tasks'
+require 'rb_sys/cargo/metadata'
+require 'rb_sys/extensiontask'
+
+task build: :compile
+
+GEMSPEC = Gem::Specification.load('temporalio.gemspec')
+
+begin
+  RbSys::ExtensionTask.new('temporalio_bridge', GEMSPEC) do |ext|
+    ext.lib_dir = 'lib/temporalio/internal/bridge'
+  end
+rescue RbSys::CargoMetadataError
+  raise 'Source gem cannot be installed directly, must be a supported platform'
+end
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.warning = false
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+def add_protoc_to_path
+  tools_spec = Gem::Specification.find_by_name('grpc-tools')
+  cpu = RbConfig::CONFIG['host_cpu']
+  cpu = 'x86_64' if cpu == 'x64'
+  os = RbConfig::CONFIG['host_os']
+  os = 'windows' if os.start_with?('mingw')
+  protoc_path = "#{tools_spec.gem_dir}/bin/#{cpu}-#{os}"
+  separator = os == 'windows' ? ';' : ':'
+  ENV['PATH'] = "#{ENV.fetch('PATH', nil)}#{separator}#{protoc_path}"
+end
+
+add_protoc_to_path
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+require 'steep/rake_task'
+
+Steep::RakeTask.new
+
+require 'yard'
+
+module CustomizeYardWarnings # rubocop:disable Style/Documentation
+  def process
+    super
+  rescue YARD::Parser::UndocumentableError
+    # We ignore if it's an API warning
+    last_file = statement.last.file
+    raise unless (last_file.start_with?('lib/temporalio/api/') && last_file.count('/') > 3) ||
+                 last_file.start_with?('lib/temporalio/internal/bridge/api/')
+  end
+end
+
+YARD::Handlers::Ruby::ConstantHandler.prepend(CustomizeYardWarnings)
+
+YARD::Rake::YardocTask.new { |t| t.options = ['--fail-on-warning'] }
+
+Rake::Task[:yard].enhance([:copy_parent_files]) do
+  rm ['LICENSE', 'README.md']
+end
+
+namespace :proto do
+  desc 'Generate API and Core protobufs'
+  task :generate do
+    require_relative 'extra/proto_gen'
+    ProtoGen.new.run
+  end
+end
+
+namespace :rbs do
+  desc 'RBS tasks'
+  task :install_collection do
+    sh 'rbs collection install'
+  end
+end
+
+# We have to copy some parent files to this dir for gem
+task :copy_parent_files do
+  cp '../LICENSE', 'LICENSE'
+  cp '../README.md', 'README.md'
+end
+Rake::Task[:build].enhance([:copy_parent_files]) do
+  rm ['LICENSE', 'README.md']
+end
+
+task :rust_lint do
+  sh 'cargo', 'clippy', '--', '-Dwarnings'
+  sh 'cargo', 'fmt', '--check'
+end
+
+task default: ['rubocop', 'yard', 'rbs:install_collection', 'steep', 'rust_lint', 'compile', 'test']

data/ext/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "temporalio_bridge"
+version = "0.1.0"
+edition = "2021"
+authors = ["Chad Retz <chad@temporal.io>"]
+license = "MIT"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+futures = "0.3"
+magnus = "0.7"
+parking_lot = "0.12"
+prost = "0.13"
+rb-sys = "0.9"
+temporal-client = { version = "0.1.0", path = "./sdk-core/client" }
+temporal-sdk-core = { version = "0.1.0", path = "./sdk-core/core", features = ["ephemeral-server"] }
+temporal-sdk-core-api = { version = "0.1.0", path = "./sdk-core/core-api" }
+temporal-sdk-core-protos = { version = "0.1.0", path = "./sdk-core/sdk-core-protos" }
+tokio = "1.26"
+tokio-util = "0.7"
+tonic = "0.12"
+tracing = "0.1"
+url = "2.2"

data/lib/temporalio/activity/complete_async_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'temporalio/error'
+
+module Temporalio
+  module Activity
+    # Error raised inside an activity to mark that the activity will be completed asynchronously.
+    class CompleteAsyncError < Error
+    end
+  end
+end

data/lib/temporalio/activity/context.rb

@@ -1,102 +1,110 @@
-require 'temporalio/error/failure'
-require 'temporalio/errors'
+# frozen_string_literal: true
+
+require 'temporalio/error'
 
 module Temporalio
-  class Activity
-    # This class provides methods that can be called from activity classes.
+  module Activity
+    # Context accessible only within an activity. Use {current} to get the current context. Contexts are fiber or thread
+    # local so may not be available in a newly started thread from an activity and may have to be propagated manually.
     class Context
-      # @api private
-      def initialize(info, heartbeat_proc, interceptors, shielded: false)
-        @thread = Thread.current
-        @info = info
-        @heartbeat_proc = heartbeat_proc
-        @interceptors = interceptors
-        @pending_cancellation = nil
-        @shielded = shielded
-        @mutex = Mutex.new
+      # @return [Context] The current context, or raises an error if not in activity fiber/thread.
+      def self.current
+        context = current_or_nil
+        raise Error, 'Not in activity context' if context.nil?
+
+        context
       end
 
-      # Information about the running activity.
-      #
-      # @return [Temporalio::Activity::Info]
-      def info
-        interceptors.invoke(:activity_info) { @info }
+      # @return [Context, nil] The current context or nil if not in activity fiber/thread.
+      def self.current_or_nil
+        _current_executor&.activity_context
       end
 
-      # Send a heartbeat for the current activity.
-      #
-      # @param details [Array<any>] Data to store with the heartbeat.
-      def heartbeat(*details)
-        interceptors.invoke(:heartbeat, *details) do |*d|
-          @heartbeat_proc.call(*d)
-        end
+      # @return [Boolean] Whether there is a current context available.
+      def self.exist?
+        !current_or_nil.nil?
       end
 
-      # Protect a part of activity's implementation from cancellations.
-      #
-      # Activity cancellations are implemented using the `Thread#raise`, which can unsafely
-      # terminate your implementation. To disable this behaviour make sure to wrap critical parts of
-      # your business logic in this method.
-      #
-      # For shielding a whole activity consider using {Temporalio::Activity.shielded!}.
-      #
-      # A cancellation that got requested while in a shielded block will not interrupt the execution
-      # and will raise a {Temporalio::Error::CancelledError} right after the block has finished.
-      #
-      # @yield Block to be protected from cancellations.
-      def shield(&block)
-        # The whole activity is shielded, called from a nested shield
-        #   or while handling a CancelledError (in a rescue or ensure blocks)
-        return block.call if @shielded || cancelled?
-
-        if Thread.current != thread
-          # TODO: Use logger instead when implemented
-          warn "Activity shielding is not intended to be used outside of activity's thread."
-          return block.call
+      # @!visibility private
+      def self._current_executor
+        if Fiber.current_scheduler
+          Fiber[:temporal_activity_executor]
+        else
+          Thread.current[:temporal_activity_executor]
         end
+      end
 
-        mutex.synchronize do
-          @shielded = true
-          result = block.call
-          # RBS: StandardError fallback is only needed to satisfy steep - https://github.com/soutaro/steep/issues/477
-          raise @pending_cancellation || StandardError if cancelled?
-
-          result
-        ensure # runs while still holding the lock
-          @shielded = false
+      # @!visibility private
+      def self._current_executor=(executor)
+        if Fiber.current_scheduler
+          Fiber[:temporal_activity_executor] = executor
+        else
+          Thread.current[:temporal_activity_executor] = executor
         end
       end
 
-      # Whether a cancellation was ever requested on this activity.
-      #
-      # @return [Boolean] true if the activity has had a cancellation request, false otherwise.
-      def cancelled?
-        !!@pending_cancellation
+      # @return [Info] Activity info for this activity.
+      def info
+        raise NotImplementedError
       end
 
-      # Cancel the running activity by raising a provided error.
+      # Record a heartbeat on the activity.
       #
-      # @param reason [String] Reason for cancellation.
-      # @param by_request [Boolean] Cancellation requested by the server or not.
+      # Heartbeats should be used for all non-immediately-returning, non-local activities and they are required to
+      # receive cancellation. Heartbeat calls are throttled internally based on the heartbeat timeout of the activity.
+      # Users do not have to be concerned with burdening the server by calling this too frequently.
       #
-      # @api private
-      def cancel(reason, by_request: false)
-        error = Temporalio::Error::ActivityCancelled.new(reason, by_request)
-        @pending_cancellation = error
-
-        locked = mutex.try_lock
-        # @shielded inside the lock means the whole activity is shielded
-        if locked && !@shielded
-          thread.raise(error)
-        end
-      ensure
-        # only release the lock if we locked it
-        mutex.unlock if locked
+      # @param details [Array<Object>] Details to record with the heartbeat.
+      def heartbeat(*details)
+        raise NotImplementedError
+      end
+
+      # @return [Cancellation] Cancellation that is canceled when the activity is canceled.
+      def cancellation
+        raise NotImplementedError
+      end
+
+      # @return [Cancellation] Cancellation that is canceled when the worker is shutting down. On worker shutdown, this
+      #   is canceled, then the `graceful_shutdown_period` is waited (default 0s), then the activity is canceled.
+      def worker_shutdown_cancellation
+        raise NotImplementedError
       end
 
-      private
+      # @return [Converters::PayloadConverter] Payload converter associated with this activity.
+      def payload_converter
+        raise NotImplementedError
+      end
+
+      # @return [ScopedLogger] Logger for this activity. Note, this is a shared logger not created each activity
+      #   invocation. It just has logic to extract current activity details and so is only able to do so on log calls
+      #   made with a current context available.
+      def logger
+        raise NotImplementedError
+      end
+
+      # @!visibility private
+      def _scoped_logger_info
+        return @scoped_logger_info unless @scoped_logger_info.nil?
 
-      attr_reader :thread, :interceptors, :mutex
+        curr_info = info
+        @scoped_logger_info = {
+          temporal_activity: {
+            activity_id: curr_info.activity_id,
+            activity_type: curr_info.activity_type,
+            attempt: curr_info.attempt,
+            task_queue: curr_info.task_queue,
+            workflow_id: curr_info.workflow_id,
+            workflow_namespace: curr_info.workflow_namespace,
+            workflow_run_id: curr_info.workflow_run_id,
+            workflow_type: curr_info.workflow_type
+          }
+        }.freeze
+      end
+
+      # @return [Metric::Meter] Metric meter to create metrics on, with some activity-specific attributes already set.
+      def metric_meter
+        raise NotImplementedError
+      end
     end
   end
 end

data/lib/temporalio/activity/definition.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Temporalio
+  module Activity
+    # Base class for all activities.
+    #
+    # Activities can be given to a worker as instances of this class, which will call execute on the same instance for
+    # each execution, or given to the worker as the class itself which instantiates the activity for each execution.
+    #
+    # All activities must implement {execute}. Inside execute, {Activity::Context.current} can be used to access the
+    # current context to get information, issue heartbeats, etc.
+    #
+    # By default, the activity is named as its unqualified class name. This can be customized with {activity_name}.
+    #
+    # By default, the activity uses the `:default` executor which is usually the thread-pool based executor. This can be
+    # customized with {activity_executor}.
+    #
+    # By default, upon cancellation {::Thread.raise} or {::Fiber.raise} is called with a {Error::CanceledError}. This
+    # can be disabled by passing `false` to {activity_cancel_raise}.
+    #
+    # See documentation for more detail on activities.
+    class Definition
+      class << self
+        protected
+
+        # Override the activity name which is defaulted to the unqualified class name.
+        #
+        # @param name [String, Symbol] Name to use.
+        def activity_name(name)
+          if !name.is_a?(Symbol) && !name.is_a?(String)
+            raise ArgumentError,
+                  'Activity name must be a symbol or string'
+          end
+
+          @activity_name = name.to_s
+        end
+
+        # Override the activity executor which is defaulted to `:default`.
+        #
+        # @param executor_name [Symbol] Executor to use.
+        def activity_executor(executor_name)
+          raise ArgumentError, 'Executor name must be a symbol' unless executor_name.is_a?(Symbol)
+
+          @activity_executor = executor_name
+        end
+
+        # Override whether the activity uses Thread/Fiber raise for cancellation which is defaulted to true.
+        #
+        # @param cancel_raise [Boolean] Whether to raise.
+        def activity_cancel_raise(cancel_raise)
+          unless cancel_raise.is_a?(TrueClass) || cancel_raise.is_a?(FalseClass)
+            raise ArgumentError, 'Must be a boolean'
+          end
+
+          @activity_cancel_raise = cancel_raise
+        end
+
+        # Set an activity as dynamic. Dynamic activities do not have names and handle any activity that is not otherwise
+        # registered. A worker can only have one dynamic activity. It is often useful to use {activity_raw_args} with
+        # this.
+        #
+        # @param value [Boolean] Whether the activity is dynamic.
+        def activity_dynamic(value = true) # rubocop:disable Style/OptionalBooleanParameter
+          raise ArgumentError, 'Must be a boolean' unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+          @activity_dynamic = value
+        end
+
+        # Have activity arguments delivered to `execute` as {Converters::RawValue}s. These are wrappers for the raw
+        # payloads that have not been converted to types (but they have been decoded by the codec if present). They can
+        # be converted with {Context#payload_converter}.
+        #
+        # @param value [Boolean] Whether the activity accepts raw arguments.
+        def activity_raw_args(value = true) # rubocop:disable Style/OptionalBooleanParameter
+          raise ArgumentError, 'Must be a boolean' unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+          @activity_raw_args = value
+        end
+      end
+
+      # @!visibility private
+      def self._activity_definition_details
+        activity_name = @activity_name
+        raise 'Cannot have activity name specified for dynamic activity' if activity_name && @activity_dynamic
+
+        # Default to unqualified class name if not dynamic
+        activity_name ||= name.to_s.split('::').last unless @activity_dynamic
+        {
+          activity_name:,
+          activity_executor: @activity_executor || :default,
+          activity_cancel_raise: @activity_cancel_raise.nil? ? true : @activity_cancel_raise,
+          activity_raw_args: @activity_raw_args.nil? ? false : @activity_raw_args
+        }
+      end
+
+      # Implementation of the activity. The arguments should be positional and this should return the value on success
+      # or raise an error on failure.
+      def execute(*args)
+        raise NotImplementedError, 'Activity did not implement "execute"'
+      end
+
+      # Definition info of an activity. Activities are usually classes/instances that extend {Definition}, but
+      # definitions can also be manually created with a block via {initialize} here.
+      class Info
+        # @return [String, Symbol, nil] Name of the activity, or nil if the activity is dynamic.
+        attr_reader :name
+
+        # @return [Proc] Proc for the activity.
+        attr_reader :proc
+
+        # @return [Symbol] Name of the executor. Default is `:default`.
+        attr_reader :executor
+
+        # @return [Boolean] Whether to raise in thread/fiber on cancellation. Default is `true`.
+        attr_reader :cancel_raise
+
+        # @return [Boolean] Whether to use {Converters::RawValue}s as arguments.
+        attr_reader :raw_args
+
+        # Obtain definition info representing the given activity, which can be a class, instance, or definition info.
+        #
+        # @param activity [Definition, Class<Definition>, Info] Activity to get info for.
+        # @return Info Obtained definition info.
+        def self.from_activity(activity)
+          # Class means create each time, instance means just call, definition
+          # does nothing special
+          case activity
+          when Class
+            unless activity < Definition
+              raise ArgumentError,
+                    "Class '#{activity}' does not extend Temporalio::Activity::Definition"
+            end
+
+            details = activity._activity_definition_details
+            new(
+              name: details[:activity_name],
+              executor: details[:activity_executor],
+              cancel_raise: details[:activity_cancel_raise],
+              raw_args: details[:activity_raw_args]
+            ) { |*args| activity.new.execute(*args) } # Instantiate and call
+          when Definition
+            details = activity.class._activity_definition_details
+            new(
+              name: details[:activity_name],
+              executor: details[:activity_executor],
+              cancel_raise: details[:activity_cancel_raise],
+              raw_args: details[:activity_raw_args]
+            ) { |*args| activity.execute(*args) } # Just and call
+          when Info
+            activity
+          else
+            raise ArgumentError, "#{activity} is not an activity class, instance, or definition info"
+          end
+        end
+
+        # Manually create activity definition info. Most users will use an instance/class of {Definition}.
+        #
+        # @param name [String, Symbol, nil] Name of the activity or nil for dynamic activity.
+        # @param executor [Symbol] Name of the executor.
+        # @param cancel_raise [Boolean] Whether to raise in thread/fiber on cancellation.
+        # @param raw_args [Boolean] Whether to use {Converters::RawValue}s as arguments.
+        # @yield Use this block as the activity.
+        def initialize(name:, executor: :default, cancel_raise: true, raw_args: false, &block)
+          @name = name
+          raise ArgumentError, 'Must give block' unless block_given?
+
+          @proc = block
+          @executor = executor
+          @cancel_raise = cancel_raise
+          @raw_args = raw_args
+        end
+      end
+    end
+  end
+end

data/lib/temporalio/activity/info.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
+
 module Temporalio
-  class Activity
-    # Class containing information about an activity.
-    class Info < Struct.new(
+  module Activity
+    Info = Data.define(
       :activity_id,
       :activity_type,
       :attempt,
       :current_attempt_scheduled_time,
       :heartbeat_details,
       :heartbeat_timeout,
-      :local,
+      :local?,
       :schedule_to_close_timeout,
       :scheduled_time,
       :start_to_close_timeout,
@@ -18,50 +19,46 @@ module Temporalio
       :workflow_id,
       :workflow_namespace,
       :workflow_run_id,
-      :workflow_type,
-      keyword_init: true,
+      :workflow_type
     )
-      # @!attribute [r] activity_id
-      #   @return [String] Activity ID.
-      # @!attribute [r] activity_type
-      #   @return [String] Name of the activity.
-      # @!attribute [r] attempt
-      #   @return [Integer] Activity's execution attempt.
-      # @!attribute [r] current_attempt_scheduled_time
-      #   @return [Time] Scheduled time of the current attempt.
-      # @!attribute [r] heartbeat_details
-      #   @return [Array<any>] Details submitted with the last heartbeat.
-      # @!attribute [r] heartbeat_timeout
-      #   @return [Float] Max time between heartbeats (in seconds).
-      # @!attribute [r] local
-      #   @return [Boolean] Whether activity is local or not.
-      # @!attribute [r] schedule_to_close_timeout
-      #   @return [Float] Max overall activity execution time (in seconds).
-      # @!attribute [r] scheduled_time
-      #   @return [Time] Time when activity was first scheduled.
-      # @!attribute [r] start_to_close_timeout
-      #   @return [Float] Max time of a single invocation (in seconds).
-      # @!attribute [r] started_time
-      #   @return [Time] Time when activity was started.
-      # @!attribute [r] task_queue
-      #   @return [String] Task queue on which the activity got scheduled.
-      # @!attribute [r] task_token
-      #   @return [String] A token for completing the activity.
-      # @!attribute [r] workflow_id
-      #   @return [String] Workflow ID.
-      # @!attribute [r] workflow_namespace
-      #   @return [String] Workflow namespace.
-      # @!attribute [r] workflow_run_id
-      #   @return [String] Workflow run ID.
-      # @!attribute [r] workflow_type
-      #   @return [String] Name of the workflow.
 
-      # Whether activity is local or not
-      #
-      # @return [Boolean] True for local activities, falst otherwise.
-      def local?
-        local
-      end
-    end
+    # Information about an activity.
+    #
+    # @!attribute activity_id
+    #   @return [String] ID for the activity.
+    # @!attribute activity_type
+    #   @return [String] Type name for the activity.
+    # @!attribute attempt
+    #   @return [Integer] Attempt the activity is on.
+    # @!attribute current_attempt_scheduled_time
+    #   @return [Time] When the current attempt was scheduled.
+    # @!attribute heartbeat_details
+    #   @return [Array<Object>] Details from the last heartbeat of the last attempt.
+    # @!attribute heartbeat_timeout
+    #   @return [Float, nil] Heartbeat timeout set by the caller.
+    # @!attribute local?
+    #   @return [Boolean] Whether the activity is a local activity or not.
+    # @!attribute schedule_to_close_timeout
+    #   @return [Float, nil] Schedule to close timeout set by the caller.
+    # @!attribute scheduled_time
+    #   @return [Time] When the activity was scheduled.
+    # @!attribute start_to_close_timeout
+    #   @return [Float, nil] Start to close timeout set by the caller.
+    # @!attribute started_time
+    #   @return [Time] When the activity started.
+    # @!attribute task_queue
+    #   @return [String] Task queue this activity is on.
+    # @!attribute task_token
+    #   @return [String] Task token uniquely identifying this activity. Note, this is a `ASCII-8BIT` encoded string, not
+    #     a `UTF-8` encoded string nor a valid UTF-8 string.
+    # @!attribute workflow_id
+    #   @return [String] Workflow ID that started this activity.
+    # @!attribute workflow_namespace
+    #   @return [String] Namespace this activity is on.
+    # @!attribute workflow_run_id
+    #   @return [String] Workflow run ID that started this activity.
+    # @!attribute workflow_type
+    #   @return [String] Workflow type name that started this activity.
+    class Info; end # rubocop:disable Lint/EmptyClass
   end
 end