expeditor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 28e3d0c9d21f60030c7e591f6fd79c849357b428
+  data.tar.gz: e3fd9e317a4d5fcd3b27bb4f9d4b8c48a03dc436
+SHA512:
+  metadata.gz: 51d080f2f60dde13877de518bdf1ad4893cc98bfa970e3e8ee9891e754445f3564c517beadcec923b62900c44ef97bb0906dcead8dd78d4f7c92f823f186f6c9
+  data.tar.gz: 95753cfcd208ebe0e29ed06a51c69bbf4589d3252e299748a83f13ed17aa326e3a1e68483bbf9b7211a50985309c30b8c8db9de4d7e79b351005495822351fb2

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rystrix.gemspec
+gemspec

data/README.md

@@ -0,0 +1,37 @@
+# Expeditor
+
+Expeditor is a Ruby library inspired by Netflix/Hystrix.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'expeditor'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install expeditor
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/expeditor/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rystrix"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/example.rb

@@ -0,0 +1,62 @@
+require 'expeditor'
+
+start_time = Time.now
+
+# Create new service (it is containing a thread pool and circuit breaker function)
+service = Expeditor::Service.new(
+  executor: Concurrent::ThreadPoolExecutor.new(
+    min_threads: 5,    # minimum number of threads
+    max_threads: 5,    # maximum number of threads
+    max_queue: 0,      # max size of task queue (including executing threads)
+  ),
+  non_break_count: 10, # max count of non break
+  threshold: 0.5,      # failure rate to break (0.0 - 1.0)
+)
+
+# Create commands
+command1 = Expeditor::Command.new(service: service) do
+  sleep 0.1
+  'command1'
+end
+
+command2 = Expeditor::Command.new(service: service, timeout: 0.5) do
+  sleep 1000
+  'command2'
+end
+# command2_d is command2 with fallback
+command2_d = command2.with_fallback do |e|
+  'command2 fallback'
+end
+
+command3 = Expeditor::Command.new(
+  service: service,
+  dependencies: [command1, command2_d]
+) do |v1, v2|
+  sleep 0.2
+  v1 + ', ' + v2
+end
+
+command4 = Expeditor::Command.new(
+  service: service,
+  dependencies: [command2, command3],
+  timeout: 1
+) do |v2, v3|
+  sleep 0.3
+  v2 + ', ' + v3
+end
+command4_d = command4.with_fallback do
+  'command4 fallback'
+end
+
+# Start command (all dependencies of command4_d are executed. this is non blocking)
+command4_d.start
+
+puts Time.now - start_time #=> 0.00...
+puts command1.get          #=> command1
+puts Time.now - start_time #=> 0.10...
+puts command2_d.get        #=> command2 fallback
+puts Time.now - start_time #=> 0.50...
+puts command4_d.get        #=> command4 fallback
+puts Time.now - start_time #=> 0.50...
+puts command3.get          #=> command3
+puts Time.now - start_time #=> 0.70...

data/expeditor.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'expeditor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "expeditor"
+  spec.version       = Expeditor::VERSION
+  spec.authors       = ["shohei-yasutake"]
+  spec.email         = ["shohei-yasutake@cookpad.com"]
+
+  spec.summary       = "Expeditor provides asynchronous execution and fault tolerance for microservices"
+  spec.description   = "Expeditor provides asynchronous execution and fault tolerance for microservices"
+  spec.homepage      = "https://github.com/cookpad/expeditor"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com' to prevent pushes to rubygems.org, or delete to allow pushes to any server."
+  end
+
+  spec.add_runtime_dependency "concurrent-ruby", "~> 0.8"
+  spec.add_runtime_dependency "concurrent-ruby-ext", "~> 0.8"
+  spec.add_runtime_dependency "retryable", "> 1.0"
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "3.2.0"
+end

data/lib/expeditor.rb

@@ -0,0 +1,7 @@
+require 'expeditor/bucket'
+require 'expeditor/command'
+require 'expeditor/errors'
+require 'expeditor/rich_future'
+require 'expeditor/service'
+require 'expeditor/status'
+require 'expeditor/version'

data/lib/expeditor/bucket.rb

@@ -0,0 +1,79 @@
+require 'expeditor/status'
+
+module Expeditor
+  class Bucket
+    def initialize(opts = {})
+      @mutex = Mutex.new
+      @current_index = 0
+      @size = opts.fetch(:size, 10)
+      @per_time = opts.fetch(:per, 1)
+      @current_start = Time.now
+      @statuses = [].fill(0..(@size - 1)) do
+        Expeditor::Status.new
+      end
+    end
+
+    def increment(type)
+      @mutex.synchronize do
+        update
+        @statuses[@current_index].increment type
+      end
+    end
+
+    def total
+      acc = @mutex.synchronize do
+        update
+        @statuses.inject([0, 0, 0, 0, 0, 0]) do |acc, s|
+          acc[0] += s.success
+          acc[1] += s.failure
+          acc[2] += s.rejection
+          acc[3] += s.timeout
+          acc[4] += s.break
+          acc[5] += s.dependency
+          acc
+        end
+      end
+      status = Expeditor::Status.new
+      status.success = acc[0]
+      status.failure = acc[1]
+      status.rejection = acc[2]
+      status.timeout = acc[3]
+      status.break = acc[4]
+      status.dependency = acc[5]
+      status
+    end
+
+    def current
+      @mutex.synchronize do
+        update
+        @statuses[@current_index]
+      end
+    end
+
+    private
+
+    def update
+      passing = last_passing
+      if passing > 0
+        @current_start = @current_start + @per_time * passing
+        passing = passing.div @size + @size if passing > 2 * @size
+        passing.times do
+          @current_index = next_index
+          @statuses[@current_index].reset
+        end
+      end
+    end
+
+    def last_passing
+      (Time.now - @current_start).div @per_time
+    end
+
+    def next_index
+      if @current_index == @size - 1
+        0
+      else
+        @current_index + 1
+      end
+    end
+  end
+end

data/lib/expeditor/command.rb

@@ -0,0 +1,242 @@
+require 'concurrent/ivar'
+require 'concurrent/executor/safe_task_executor'
+require 'concurrent/configuration'
+require 'expeditor/errors'
+require 'expeditor/rich_future'
+require 'expeditor/service'
+require 'expeditor/services'
+require 'retryable'
+require 'timeout'
+
+module Expeditor
+  class Command
+    def initialize(opts = {}, &block)
+      @service = opts.fetch(:service, Expeditor::Services.default)
+      @timeout = opts[:timeout]
+      @dependencies = opts.fetch(:dependencies, [])
+      @normal_future = initial_normal(&block)
+      @fallback_var = nil
+      @retryable_options = Concurrent::IVar.new
+    end
+
+    def start
+      if not started?
+        @dependencies.each(&:start)
+        @normal_future.safe_execute
+      end
+      self
+    end
+
+    # Equivalent to retryable gem options
+    def start_with_retry(retryable_options = {})
+      if not started?
+        @retryable_options.set(retryable_options)
+        start
+      end
+      self
+    end
+
+    def started?
+      @normal_future.executed?
+    end
+
+    def get
+      raise NotStartedError if not started?
+      @normal_future.get_or_else do
+        if @fallback_var
+          @fallback_var.wait
+          if @fallback_var.rejected?
+            raise @fallback_var.reason
+          else
+            @fallback_var.value
+          end
+        else
+          raise @normal_future.reason
+        end
+      end
+    end
+
+    def with_fallback(&block)
+      command = self.clone
+      command.reset_fallback(&block)
+      command
+    end
+
+    def wait
+      raise NotStartedError if not started?
+      @normal_future.wait
+      @fallback_var.wait if @fallback_var
+    end
+
+    # command.on_complete do |success, value, reason|
+    #   ...
+    # end
+    def on_complete(&block)
+      on do |_, value, reason|
+        block.call(reason == nil, value, reason)
+      end
+    end
+
+    # command.on_success do |value|
+    #   ...
+    # end
+    def on_success(&block)
+      on do |_, value, reason|
+        block.call(value) unless reason
+      end
+    end
+
+    # command.on_failure do |e|
+    #   ...
+    # end
+    def on_failure(&block)
+      on do |_, _, reason|
+        block.call(reason) if reason
+      end
+    end
+
+    # `chain` returns new command that has self as dependencies
+    def chain(opts = {}, &block)
+      opts[:dependencies] = [self]
+      Command.new(opts, &block)
+    end
+
+    def self.const(value)
+      ConstCommand.new(value)
+    end
+
+    def self.start(opts = {}, &block)
+      Command.new(opts, &block).start
+    end
+
+    protected
+
+    def reset_fallback(&block)
+      @fallback_var = Concurrent::IVar.new
+      @normal_future.add_observer do |_, value, reason|
+        if reason != nil
+          future = RichFuture.new(executor: Concurrent.configuration.global_task_pool) do
+            success, val, reason = Concurrent::SafeTaskExecutor.new(block, rescue_exception: true).execute(reason)
+            @fallback_var.complete(success, val, reason)
+          end
+          future.safe_execute
+        else
+          @fallback_var.complete(true, value, nil)
+        end
+      end
+    end
+
+    private
+
+    def breakable_block(args, &block)
+      if @service.open?
+        raise CircuitBreakError
+      else
+        block.call(*args)
+      end
+    end
+
+    def retryable_block(args, &block)
+      if @retryable_options.fulfilled?
+        Retryable.retryable(@retryable_options.value) do |retries, exception|
+          metrics(exception) if retries > 0
+          breakable_block(args, &block)
+        end
+      else
+        breakable_block(args, &block)
+      end
+    end
+
+    def timeout_block(args, &block)
+      if @timeout
+        Timeout::timeout(@timeout) do
+          retryable_block(args, &block)
+        end
+      else
+        retryable_block(args, &block)
+      end
+    end
+
+    def metrics(reason)
+      case reason
+      when nil
+        @service.success
+      when Timeout::Error
+        @service.timeout
+      when RejectedExecutionError
+        @service.rejection
+      when CircuitBreakError
+        @service.break
+      when DependencyError
+        @service.dependency
+      else
+        @service.failure
+      end
+    end
+
+    # timeout do
+    #   retryable do
+    #     circuit break do
+    #       block.call
+    #     end
+    #   end
+    # end
+    def initial_normal(&block)
+      future = RichFuture.new(executor: @service.executor) do
+        args = wait_dependencies
+        timeout_block(args, &block)
+      end
+      future.add_observer do |_, _, reason|
+        metrics(reason)
+      end
+      future
+    end
+
+    def wait_dependencies
+      if @dependencies.count > 0
+        current = Thread.current
+        executor = Concurrent::ThreadPoolExecutor.new(
+          min_threads: 0,
+          max_threads: 5,
+          max_queue: 0,
+        )
+        error = Concurrent::IVar.new
+        error.add_observer do |_, e, _|
+          executor.shutdown
+          current.raise(DependencyError.new(e))
+        end
+        args = []
+        @dependencies.each_with_index do |c, i|
+          executor.post do
+            begin
+              args[i] = c.get
+            rescue => e
+              error.set(e)
+            end
+          end
+        end
+        executor.shutdown
+        executor.wait_for_termination
+        args
+      else
+        []
+      end
+    end
+
+    def on(&callback)
+      if @fallback_var
+        @fallback_var.add_observer(&callback)
+      else
+        @normal_future.add_observer(&callback)
+      end
+    end
+
+    class ConstCommand < Command
+      def initialize(value)
+        @service = Expeditor::Services.default
+        @dependencies = []
+        @normal_future = RichFuture.new {}.set(value)
+      end
+    end
+  end
+end

data/lib/expeditor/errors.rb

@@ -0,0 +1,13 @@
+require 'concurrent/errors'
+
+module Expeditor
+  NotStartedError = Class.new(StandardError)
+  RejectedExecutionError = Concurrent::RejectedExecutionError
+  CircuitBreakError = Class.new(StandardError)
+  class DependencyError < StandardError
+    attr :error
+    def initialize(e)
+      @error = e
+    end
+  end
+end

data/lib/expeditor/rich_future.rb

@@ -0,0 +1,61 @@
+require 'concurrent/configuration'
+require 'concurrent/future'
+
+module Expeditor
+  class RichFuture < Concurrent::Future
+    def get
+      wait
+      if rejected?
+        raise reason
+      else
+        value
+      end
+    end
+
+    def get_or_else(&block)
+      wait
+      if rejected?
+        block.call
+      else
+        value
+      end
+    end
+
+    def set(v)
+      super(v)
+    end
+
+    def safe_set(v)
+      set(v) unless completed?
+    end
+
+    def fail(e)
+      super(e)
+    end
+
+    def safe_fail(e)
+      fail(e) unless completed?
+    end
+
+    def executed?
+      not unscheduled?
+    end
+
+    def safe_execute
+      begin
+        execute
+      rescue Exception => e
+        fail(e)
+      end
+    end
+
+    private
+
+    # This is workaround for concurrent-ruby's deadlock bug
+    # see: ruby-concurrency/concurrent-ruby#275
+    def work
+      success, val, reason = Concurrent::SafeTaskExecutor.new(@task, rescue_exception: true).execute(*@args)
+      complete(success, val, reason)
+    end
+  end
+end

data/lib/expeditor/service.rb

@@ -0,0 +1,82 @@
+require 'concurrent/executor/thread_pool_executor'
+
+module Expeditor
+  class Service
+    attr_reader :executor
+
+    def initialize(opts = {})
+      @executor = opts.fetch(:executor) { Concurrent::ThreadPoolExecutor.new }
+      @threshold = opts.fetch(:threshold, 0.5) # is 0.5 ok?
+      @non_break_count = opts.fetch(:non_break_count, 100) # is 100 ok?
+      @sleep = opts.fetch(:sleep, 1)
+      bucket_opts = {
+        size: 10,
+        per: opts.fetch(:period, 10).to_f / 10
+      }
+      @bucket = Expeditor::Bucket.new(bucket_opts)
+      @breaking = false
+      @break_start = nil
+    end
+
+    def success
+      @bucket.increment :success
+    end
+
+    def failure
+      @bucket.increment :failure
+    end
+
+    def rejection
+      @bucket.increment :rejection
+    end
+
+    def timeout
+      @bucket.increment :timeout
+    end
+
+    def break
+      @bucket.increment :break
+    end
+
+    def dependency
+      @bucket.increment :dependency
+    end
+
+    # break circuit?
+    def open?
+      if @breaking
+        if Time.now - @break_start > @sleep
+          @breaking = false
+          @break_start = nil
+        else
+          return true
+        end
+      end
+      open = calc_open
+      if open
+        @breaking = true
+        @break_start = Time.now
+      end
+      open
+    end
+
+    # shutdown thread pool
+    # after shutdown, if you create thread, RejectedExecutionError is raised.
+    def shutdown
+      @executor.shutdown
+    end
+
+    private
+
+    def calc_open
+      s = @bucket.total
+      total_count = s.success + s.failure + s.timeout
+      if total_count >= [@non_break_count, 1].max
+        failure_count = s.failure + s.timeout
+        failure_count.to_f / total_count.to_f >= @threshold
+      else
+        false
+      end
+    end
+  end
+end

data/lib/expeditor/services.rb

@@ -0,0 +1,14 @@
+require 'concurrent/configuration'
+require 'expeditor/services/default'
+
+module Expeditor
+  module Services
+    DEFAULT_SERVICE = Expeditor::Services::Default.new
+    private_constant :DEFAULT_SERVICE
+
+    def default
+      DEFAULT_SERVICE
+    end
+    module_function :default
+  end
+end

data/lib/expeditor/services/default.rb

@@ -0,0 +1,35 @@
+require 'concurrent/configuration'
+require 'expeditor/service'
+
+module Expeditor
+  module Services
+    class Default < Expeditor::Service
+      def initialize
+        @executor = Concurrent.configuration.global_task_pool
+        @bucket = nil
+      end
+
+      def success
+      end
+
+      def failure
+      end
+
+      def rejection
+      end
+
+      def timeout
+      end
+
+      def break
+      end
+
+      def dependency
+      end
+
+      def open?
+        false
+      end
+    end
+  end
+end

data/lib/expeditor/status.rb

@@ -0,0 +1,47 @@
+module Expeditor
+  class Status
+    attr_accessor :success
+    attr_accessor :failure
+    attr_accessor :rejection
+    attr_accessor :timeout
+    attr_accessor :break
+    attr_accessor :dependency
+
+    def initialize
+      set(0, 0, 0, 0, 0, 0)
+    end
+
+    def increment(type)
+      case type
+      when :success
+        @success += 1
+      when :failure
+        @failure += 1
+      when :rejection
+        @rejection += 1
+      when :timeout
+        @timeout += 1
+      when :break
+        @break += 1
+      when :dependency
+        @dependency += 1
+      else
+      end
+    end
+
+    def reset
+      set(0, 0, 0, 0, 0, 0)
+    end
+
+    private
+
+    def set(s, f, r, t, b, d)
+      @success = s
+      @failure = f
+      @rejection = r
+      @timeout = t
+      @break = b
+      @dependency = d
+    end
+  end
+end

data/lib/expeditor/version.rb

@@ -0,0 +1,3 @@
+module Expeditor
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: expeditor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- shohei-yasutake
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby-ext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: retryable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>'
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+description: Expeditor provides asynchronous execution and fault tolerance for microservices
+email:
+- shohei-yasutake@cookpad.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/example.rb
+- expeditor.gemspec
+- lib/expeditor.rb
+- lib/expeditor/bucket.rb
+- lib/expeditor/command.rb
+- lib/expeditor/errors.rb
+- lib/expeditor/rich_future.rb
+- lib/expeditor/service.rb
+- lib/expeditor/services.rb
+- lib/expeditor/services/default.rb
+- lib/expeditor/status.rb
+- lib/expeditor/version.rb
+homepage: https://github.com/cookpad/expeditor
+licenses: []
+metadata:
+  allowed_push_host: 'TODO: Set to ''http://mygemserver.com'' to prevent pushes to
+    rubygems.org, or delete to allow pushes to any server.'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Expeditor provides asynchronous execution and fault tolerance for microservices
+test_files: []