cadence-ruby 0.0.0 → 0.1.0

data/cadence.gemspec

@@ -7,10 +7,17 @@ Gem::Specification.new do |spec|
   spec.email         = ['anthony.dmitriyev@coinbase.com']
 
   spec.summary       = 'Cadence Ruby client'
-  spec.description   = 'A complete Ruby solution for integrating with Cadence'
+  spec.description   = 'A Ruby client for implementing Cadence workflows and activities in Ruby'
   spec.homepage      = 'https://github.com/coinbase/cadence-ruby'
   spec.license       = 'Apache-2.0'
 
   spec.require_paths = ['lib']
-  spec.files         = ['lib/cadence.rb', 'lib/cadence/version.rb', 'cadence.gemspec', 'Gemfile', 'LICENSE', 'README.md']
+  spec.files         = Dir["{lib,rbi}/**/*.*"] + %w(cadence.gemspec Gemfile LICENSE README.md)
+
+  spec.add_dependency 'thrift'
+  spec.add_dependency 'oj'
+
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'fabrication'
 end

data/lib/cadence-ruby.rb

@@ -0,0 +1 @@
+require 'cadence'

data/lib/cadence.rb

@@ -1,2 +1,178 @@
+require 'securerandom'
+require 'cadence/configuration'
+require 'cadence/execution_options'
+require 'cadence/client'
+require 'cadence/activity'
+require 'cadence/activity/async_token'
+require 'cadence/workflow'
+require 'cadence/workflow/history'
+require 'cadence/workflow/execution_info'
+require 'cadence/metrics'
+
 module Cadence
+  class << self
+    def start_workflow(workflow, *input, **args)
+      options = args.delete(:options) || {}
+      input << args unless args.empty?
+
+      execution_options = ExecutionOptions.new(workflow, options)
+      workflow_id = options[:workflow_id] || SecureRandom.uuid
+
+      response = client.start_workflow_execution(
+        domain: execution_options.domain,
+        workflow_id: workflow_id,
+        workflow_name: execution_options.name,
+        task_list: execution_options.task_list,
+        input: input,
+        execution_timeout: execution_options.timeouts[:execution],
+        task_timeout: execution_options.timeouts[:task],
+        workflow_id_reuse_policy: options[:workflow_id_reuse_policy],
+        headers: execution_options.headers
+      )
+
+      response.runId
+    end
+
+    def schedule_workflow(workflow, cron_schedule, *input, **args)
+      options = args.delete(:options) || {}
+      input << args unless args.empty?
+
+      execution_options = ExecutionOptions.new(workflow, options)
+      workflow_id = options[:workflow_id] || SecureRandom.uuid
+
+      response = client.start_workflow_execution(
+        domain: execution_options.domain,
+        workflow_id: workflow_id,
+        workflow_name: execution_options.name,
+        task_list: execution_options.task_list,
+        input: input,
+        execution_timeout: execution_options.timeouts[:execution],
+        task_timeout: execution_options.timeouts[:task],
+        workflow_id_reuse_policy: options[:workflow_id_reuse_policy],
+        headers: execution_options.headers,
+        cron_schedule: cron_schedule
+      )
+
+      response.runId
+    end
+
+    def register_domain(name, description = nil)
+      client.register_domain(name: name, description: description)
+    rescue CadenceThrift::DomainAlreadyExistsError
+      nil
+    end
+
+    def signal_workflow(workflow, signal, workflow_id, run_id, input = nil)
+      client.signal_workflow_execution(
+        domain: workflow.domain, # TODO: allow passing domain instead
+        workflow_id: workflow_id,
+        run_id: run_id,
+        signal: signal,
+        input: input
+      )
+    end
+
+    def reset_workflow(domain, workflow_id, run_id, decision_task_id: nil, reason: 'manual reset')
+      decision_task_id ||= get_last_completed_decision_task(domain, workflow_id, run_id)
+      raise Error, 'Could not find a completed decision task event' unless decision_task_id
+
+      response = client.reset_workflow_execution(
+        domain: domain,
+        workflow_id: workflow_id,
+        run_id: run_id,
+        reason: reason,
+        decision_task_event_id: decision_task_id
+      )
+
+      response.runId
+    end
+
+    def terminate_workflow(domain, workflow_id, run_id, reason: 'manual termination', details: nil)
+      client.terminate_workflow_execution(
+        domain: domain,
+        workflow_id: workflow_id,
+        run_id: run_id,
+        reason: reason,
+        details: details
+      )
+    end
+
+    def fetch_workflow_execution_info(domain, workflow_id, run_id)
+      response = client.describe_workflow_execution(
+        domain: domain,
+        workflow_id: workflow_id,
+        run_id: run_id
+      )
+
+      Workflow::ExecutionInfo.generate_from(response.workflowExecutionInfo)
+    end
+
+    def complete_activity(async_token, result = nil)
+      details = Activity::AsyncToken.decode(async_token)
+
+      client.respond_activity_task_completed_by_id(
+        domain: details.domain,
+        activity_id: details.activity_id,
+        workflow_id: details.workflow_id,
+        run_id: details.run_id,
+        result: result
+      )
+    end
+
+    def fail_activity(async_token, error)
+      details = Activity::AsyncToken.decode(async_token)
+
+      client.respond_activity_task_failed_by_id(
+        domain: details.domain,
+        activity_id: details.activity_id,
+        workflow_id: details.workflow_id,
+        run_id: details.run_id,
+        reason: error.class.name,
+        details: error.message
+      )
+    end
+
+    def configure(&block)
+      yield configuration
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def logger
+      configuration.logger
+    end
+
+    def metrics
+      @metrics ||= Metrics.new(configuration.metrics_adapter)
+    end
+
+    def get_workflow_history(domain:, workflow_id:, run_id:)
+      history_response = client.get_workflow_execution_history(
+        domain: domain,
+        workflow_id: workflow_id,
+        run_id: run_id
+      )
+      Workflow::History.new(history_response.history.events)
+    end
+
+    private
+
+    def client
+      @client ||= Cadence::Client.generate
+    end
+
+    def get_last_completed_decision_task(domain, workflow_id, run_id)
+      history = get_workflow_history(
+        domain: domain,
+        workflow_id: workflow_id,
+        run_id: run_id
+      )
+
+      decision_task_event = history.last_completed_decision_task
+
+      decision_task_event&.id
+    end
+  end
 end

data/lib/cadence/activity.rb

@@ -0,0 +1,33 @@
+require 'cadence/activity/workflow_convenience_methods'
+require 'cadence/concerns/executable'
+require 'cadence/errors'
+
+module Cadence
+  class Activity
+    extend WorkflowConvenienceMethods
+    extend Concerns::Executable
+
+    def self.execute_in_context(context, input)
+      activity = new(context)
+      activity.execute(*input)
+    end
+
+    def initialize(context)
+      @context = context
+    end
+
+    def execute(*_args)
+      raise NotImplementedError, '#execute method must be implemented by a subclass'
+    end
+
+    private
+
+    def activity
+      @context
+    end
+
+    def logger
+      activity.logger
+    end
+  end
+end

data/lib/cadence/activity/async_token.rb

@@ -0,0 +1,34 @@
+require 'base64'
+
+module Cadence
+  class Activity
+    class AsyncToken
+      SEPARATOR = '|'.freeze
+
+      attr_reader :domain, :activity_id, :workflow_id, :run_id
+
+      def self.encode(domain, activity_id, workflow_id, run_id)
+        new(domain, activity_id, workflow_id, run_id).to_s
+      end
+
+      def self.decode(token)
+        string = Base64.urlsafe_decode64(token)
+        domain, activity_id, workflow_id, run_id = string.split(SEPARATOR)
+
+        new(domain, activity_id, workflow_id, run_id)
+      end
+
+      def initialize(domain, activity_id, workflow_id, run_id)
+        @domain = domain
+        @activity_id = activity_id
+        @workflow_id = workflow_id
+        @run_id = run_id
+      end
+
+      def to_s
+        parts = [domain, activity_id, workflow_id, run_id]
+        Base64.urlsafe_encode64(parts.join(SEPARATOR)).freeze
+      end
+    end
+  end
+end

data/lib/cadence/activity/context.rb

@@ -0,0 +1,64 @@
+# This context class is available in the activity implementation
+# and provides context and methods for interacting with Cadence
+#
+require 'cadence/uuid'
+require 'cadence/activity/async_token'
+
+module Cadence
+  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.domain,
+          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
+        Cadence.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/cadence/activity/poller.rb

@@ -0,0 +1,89 @@
+require 'cadence/client'
+require 'cadence/thread_pool'
+require 'cadence/middleware/chain'
+require 'cadence/activity/task_processor'
+
+module Cadence
+  class Activity
+    class Poller
+      DEFAULT_OPTIONS = {
+        thread_pool_size: 20
+      }.freeze
+
+      def initialize(domain, task_list, activity_lookup, middleware = [], options = {})
+        @domain = domain
+        @task_list = task_list
+        @activity_lookup = activity_lookup
+        @middleware = middleware
+        @options = DEFAULT_OPTIONS.merge(options)
+        @shutting_down = false
+      end
+
+      def start
+        @shutting_down = false
+        @thread = Thread.new(&method(:poll_loop))
+      end
+
+      def stop
+        @shutting_down = true
+        Cadence.logger.info('Shutting down activity poller')
+      end
+
+      def wait
+        thread.join
+        thread_pool.shutdown
+      end
+
+      private
+
+      attr_reader :domain, :task_list, :activity_lookup, :middleware, :options, :thread
+
+      def client
+        @client ||= Cadence::Client.generate(options)
+      end
+
+      def shutting_down?
+        @shutting_down
+      end
+
+      def poll_loop
+        last_poll_time = Time.now
+        metrics_tags = { domain: domain, task_list: task_list }.freeze
+
+        loop do
+          thread_pool.wait_for_available_threads
+
+          return if shutting_down?
+
+          time_diff_ms = ((Time.now - last_poll_time) * 1000).round
+          Cadence.metrics.timing('activity_poller.time_since_last_poll', time_diff_ms, metrics_tags)
+          Cadence.logger.debug("Polling for activity tasks (#{domain} / #{task_list})")
+
+          task = poll_for_task
+          last_poll_time = Time.now
+          next unless task&.activityId
+
+          thread_pool.schedule { process(task) }
+        end
+      end
+
+      def poll_for_task
+        client.poll_for_activity_task(domain: domain, task_list: task_list)
+      rescue StandardError => error
+        Cadence.logger.error("Unable to poll for an activity task: #{error.inspect}")
+        nil
+      end
+
+      def process(task)
+        client = Cadence::Client.generate
+        middleware_chain = Middleware::Chain.new(middleware)
+
+        TaskProcessor.new(task, domain, activity_lookup, client, middleware_chain).process
+      end
+
+      def thread_pool
+        @thread_pool ||= ThreadPool.new(options[:thread_pool_size])
+      end
+    end
+  end
+end

data/lib/cadence/activity/task_processor.rb

@@ -0,0 +1,73 @@
+require 'cadence/metadata'
+require 'cadence/activity/context'
+require 'cadence/json'
+
+module Cadence
+  class Activity
+    class TaskProcessor
+      def initialize(task, domain, activity_lookup, client, middleware_chain)
+        @task = task
+        @domain = domain
+        @task_token = task.taskToken
+        @activity_name = task.activityType.name
+        @activity_class = activity_lookup.find(activity_name)
+        @client = client
+        @middleware_chain = middleware_chain
+      end
+
+      def process
+        start_time = Time.now
+
+        Cadence.logger.info("Processing activity task for #{activity_name}")
+        Cadence.metrics.timing('activity_task.queue_time', queue_time_ms, activity: activity_name)
+
+        if !activity_class
+          respond_failed('ActivityNotRegistered', 'Activity is not registered with this worker')
+          return
+        end
+
+        metadata = Metadata.generate(Metadata::ACTIVITY_TYPE, task, domain)
+        context = Activity::Context.new(client, metadata)
+
+        result = middleware_chain.invoke(metadata) do
+          activity_class.execute_in_context(context, JSON.deserialize(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.class.name, error.message)
+      rescue Exception => error
+        Cadence.logger.fatal("Activity #{activity_name} unexpectedly failed with: #{error.inspect}")
+        Cadence.logger.debug(error.backtrace.join("\n"))
+        raise
+      ensure
+        time_diff_ms = ((Time.now - start_time) * 1000).round
+        Cadence.metrics.timing('activity_task.latency', time_diff_ms, activity: activity_name)
+        Cadence.logger.debug("Activity task processed in #{time_diff_ms}ms")
+      end
+
+      private
+
+      attr_reader :task, :domain, :task_token, :activity_name, :activity_class, :client, :middleware_chain
+
+      def queue_time_ms
+        ((task.startedTimestamp - task.scheduledTimestampOfThisAttempt) / 1_000_000).round
+      end
+
+      def respond_completed(result)
+        Cadence.logger.info("Activity #{activity_name} completed")
+        client.respond_activity_task_completed(task_token: task_token, result: result)
+      rescue StandardError => error
+        Cadence.logger.error("Unable to complete Activity #{activity_name}: #{error.inspect}")
+      end
+
+      def respond_failed(reason, details)
+        Cadence.logger.error("Activity #{activity_name} failed with: #{reason}")
+        client.respond_activity_task_failed(task_token: task_token, reason: reason, details: details)
+      rescue StandardError => error
+        Cadence.logger.error("Unable to fail Activity #{activity_name}: #{error.inspect}")
+      end
+    end
+  end
+end