wrapbox 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00df8d3c0e46ae38cdef3ada6dde9db32adf2313b03d910591e98a9129b1d787
-  data.tar.gz: 61739c6ac9544da2b2ea83fd538831e6782ee78d9e0d2ddc8f2424e409d48474
+  metadata.gz: bdb5f8dc31647c10b941f003cc2c0c16127210e38e922abe1ed6f24a691ac497
+  data.tar.gz: 8fce00a8ada4301f82a079c57a51a9d85fb4502ae95b13ce0a0582d83f3eef70
 SHA512:
-  metadata.gz: 97c9a51c95c80f93ec16443eaca2e91890da6a1d7574f6d62be200ac2db8a997bcae61dc74da0467b3aa4aac751c81db86ea3943f86988ff78644b52efad92d3
-  data.tar.gz: bae99aa04b2540582132f769d0db1b20dd171956cef2bd8fb08b4d16f430365c56ba86a0c706ad37b6499ee0b037093828703d752ae0672f9d16e4ad0a1ace59
+  metadata.gz: d49adcac17d1390776a19992e9636680617dda700f6084c8e6b06e17d300b133cf452ed7f80d50eea84c2e0b6b9e97121629b4e3255263726172e520d3d7dfe2
+  data.tar.gz: 3ef0163a2dfd7180f8dfbff4508f4c7171f7bfd29a828c71744523e1bcdc647553cb37aa9a353ab5c06a796224168a08c362662b5211ea770b062cd2eb3a43ad

data/.dockerignore

@@ -7,6 +7,5 @@ doc
 pkg
 spec/reports
 tmp
-.travis.yml
 
 .envrc

data/.github/workflows/main.yml

@@ -0,0 +1,30 @@
+name: Testing on Ubuntu
+on:
+  - push
+  - pull_request
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 10
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+          - 2.7
+          - 3.0
+          - 3.1
+          - 3.2
+        os:
+          - ubuntu-latest
+    name: Ruby ${{ matrix.ruby }} unit testing on ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: unit testing
+      env:
+        CI: true
+      run: |
+        bundle install --jobs 4 --retry 3
+        bundle exec rake spec

data/README.md

@@ -78,6 +78,13 @@ Wrapbox.run("TestJob", :perform, ["arg1", ["arg2", "arg3"]], config_name: :docke
 Wrapbox.run_cmd(["ls ."], environments: [{name: "RAILS_ENV", value: "development"}])
 ```
 
+If ECS runner cannot create task, it puts custom metric data to CloudWatch.
+Custom metric data is `wrapbox/WaitingTaskCount` that has `ClusterName` dimension.
+And, it retry launching until retry count reach `launch_retry`.
+
+After task exited, Wrapbox checks main container exit code.
+If exit code is not 0, Wrapbox raise error.
+
 ## Config
 
 ### Common
@@ -88,20 +95,25 @@ Wrapbox.run_cmd(["ls ."], environments: [{name: "RAILS_ENV", value: "development
 
 ### for ECS
 
-| name                  | desc                                                                                                        |
-| --------------------  | ------------------------------------------------                                                            |
-| cluster               | target ECS cluster name                                                                                     |
-| region                | region of ECS cluster                                                                                       |
-| container_definitions | see. http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
-| task_role_arn         | see. http://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html                         |
-| volumes               | see. http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
-| placement_constraints | see. http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
-| placement_strategy    | see. http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
-| launch_type           | see. http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#run_task-instance_method                 |
-| newtork_mode          | see. http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
-| network_configuration | see. http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#run_task-instance_method                 |
-| cpu    | see. http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
-| memory    | see. http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
+| name                       | desc                                                                                                       |
+| -------------------------- | ------------------------------------------------                                                           |
+| cluster                    | target ECS cluster name                                                                                    |
+| region                     | region of ECS cluster                                                                                      |
+| container_definitions      | see http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
+| task_role_arn              | see http://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html                         |
+| volumes                    | see http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
+| placement_constraints      | see http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
+| placement_strategy         | see http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
+| launch_type                | see http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#run_task-instance_method                 |
+| network_mode               | see http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
+| network_configuration      | see http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#run_task-instance_method                 |
+| capacity_provider_strategy | see https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ECS/Client.html#run_task-instance_method           |
+| cpu                        | see http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
+| memory                     | see http://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
+| enable_ecs_managed_tags    | see https://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#run_task-instance_method                |
+| tags                       | tags of task definitions. see also https://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#register_task_definition-instance_method |
+| propagate_tags             | specify `"TASK_DEFINITION"` if you want to propagate tags to tasks. see also https://docs.aws.amazon.com/sdkforruby/api/Aws/ECS/Client.html#run_task-instance_method |
+| launch_instances           | specify `launch_template` (required), `instance_type`, and `tag_specifications` for [Aws::EC2::Client#run_instances](https://docs.aws.amazon.com/sdkforruby/api/Aws/EC2/Client.html#run_instances-instance_method). You can also specify `wait_until_instance_terminated` (default: true) |
 
 `WRAPBOX_CMD_INDEX` environment variable is available in `run_cmd` and you can distinguish logs from each command like below:
 
@@ -119,28 +131,59 @@ log_configuration:
 | --------------------  | ----------------------------------------------------------- |
 | container_definitions | only use `image`, `cpu`, `memory`, and `memory_reservation` |
 | keep_container        | If true, doesn't delete the container when the command ends |
-| use_sudo              | If true, invoke `sudo docker` command                       |
 
 ## API
 
-#### `run(class_name, method_name, args, container_definition_overrides: {}, environments: [], task_role_arn: nil, cluster: nil, timeout: 3600 * 24, launch_timeout: 60 * 10, launch_retry: 10, retry_interval: 1, retry_interval_multiplier: 2, max_retry_interval: 120, execution_retry: 0)`
+### `Wrapbox.run`
 
-#### `run_cmd(*cmd, container_definition_overrides: {}, environments: [], task_role_arn: nil, cluster: nil, timeout: 3600 * 24, launch_timeout: 60 * 10, launch_retry: 10, retry_interval: 1, retry_interval_multiplier: 2, max_retry_interval: 120, execution_retry: 0)`
-
-following options is only for ECS.
-
-- task_role_arn
-- cluster
-- timeout
-- launch_timeout
-- launch_retry
+```ruby
+Wrapbox.run(class_name, method_name, args,
+  runner: nil, # The "runner" value is used in the configuration  if it is nil.
+  config_name: nil, # "default" configuration is used if it is nil.
+  cluster: nil, # Available only for ECS runner. The "cluster" value in the configuration is used if it is nil.
+  launch_type: "EC2", # Available only for ECS runner. The "launch_type" value in the configuration is used if it is nil.
+  task_role_arn: nil, # Available only for ECS runner. The "task_role_arn" value in the configuration is used if it is nil.
+  execution_role_arn: nil, # Available only for ECS runner. The "execution_role_arn" value in the configuration is used if it is nil.
+  tags: nil, # Available only for ECS runner. The "tags" value in the configuration is used if it is nil.
+  propagate_tags: nil, # Available only for ECS runner. The "propagate_tags" value in the configuration is used if it is nil.
+  container_definition_overrides: {},
+  environments: [],
+  timeout: 3600 * 24, # Available only for ECS runner. # Available only for ECS runner.
+  launch_timeout: 60 * 10, # Available only for ECS runner.
+  launch_retry: 10, # Available only for ECS runner.
+  retry_interval: 1, # Available only for ECS runner.
+  retry_interval_multiplier: 2, # Available only for ECS runner.
+  max_retry_interval: 120, # Available only for ECS runner.
+  execution_retry: 0, # Available only for ECS runner.
+  keep_container: nil, # Available only for Docker runner. The "keep_container" value in the configuration is used if it is nil.
+)
+```
 
-If Wrapbox cannot create task, it puts custom metric data to CloudWatch.
-Custom metric data is `wrapbox/WaitingTaskCount` that has `ClusterName` dimension.
-And, it retry launching until retry count reach `launch_retry`.
+### `Wrapbox.run_cmd`
 
-After task exited, Wrapbox checks main container exit code.
-If exit code is not 0, Wrapbox raise error.
+```ruby
+Wrapbox.run_cmd(*cmd,
+  runner: nil, # The "runner" value is used in the configuration  if it is nil.
+  config_name: nil, # "default" configuration is used if it is nil.
+  cluster: nil, # Available only for ECS runner. The "cluster" value in the configuration is used if it is nil.
+  launch_type: "EC2", # Available only for ECS runner. The "launch_type" value in the configuration is used if it is nil.
+  task_role_arn: nil, # Available only for ECS runner. The "task_role_arn" value in the configuration is used if it is nil.
+  execution_role_arn: nil, # Available only for ECS runner. The "execution_role_arn" value in the configuration is used if it is nil.
+  tags: nil, # Available only for ECS runner. The "tags" value in the configuration is used if it is nil.
+  propagate_tags: nil, # Available only for ECS runner. The "propagate_tags" value in the configuration is used if it is nil.
+  container_definition_overrides: {},
+  ignore_signal: false,
+  environments: [],
+  timeout: 3600 * 24, # Available only for ECS runner. # Available only for ECS runner.
+  launch_timeout: 60 * 10, # Available only for ECS runner.
+  launch_retry: 10, # Available only for ECS runner.
+  retry_interval: 1, # Available only for ECS runner.
+  retry_interval_multiplier: 2, # Available only for ECS runner.
+  max_retry_interval: 120, # Available only for ECS runner.
+  execution_retry: 0, # Available only for ECS runner.
+  keep_container: nil, # Available only for Docker runner. The "keep_container" value in the configuration is used if it is nil.
+)
+```
 
 ## Development
 
@@ -148,6 +191,27 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 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`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+### How to test
+
+The following environment variables are required to run all tests.
+
+Name | Description
+-----|----------------
+RUN_AWS_SPECS | Set "true" to run tests with `aws` set to true. You should also set credentials for AWS account to run ECS tasks.
+ECS_CLUSTER | A cluster used in tests. "default" cluster is used if this variable is not set.
+OVERRIDDEN_ECS_CLUSTER | A cluster used in tests that ensure `cluster` parameter.
+LAUNCH_TEMPLATE_ID | A launch template used in tests that ensure `launch_instances` configuration.
+
+
+```
+env \
+  RUN_AWS_SPECS=true \
+  ECS_CLUSTER='some_cluster' \
+  OVERRIDDEN_ECS_CLUSTER='another_cluster' \
+  LAUNCH_TEMPLATE_ID=lt-xxxxxxxxxxxxxxxxx \
+bundle exec rspec
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/reproio/wrapbox.

data/lib/wrapbox/config_repository.rb

@@ -8,7 +8,12 @@ module Wrapbox
     end
 
     def load_yaml(yaml_file)
-      configs = YAML.load(ERB.new(File.read(yaml_file)).result)
+      file = ERB.new(File.read(yaml_file)).result
+      configs = if Gem::Version.new(Psych::VERSION) >= Gem::Version.new("4.0.0")
+        YAML.load(file, aliases: true)
+      else
+        YAML.load(file)
+      end
       configs.each do |name, configuration|
         load_config(name, configuration.merge("name" => name))
       end

data/lib/wrapbox/configuration.rb

@@ -1,3 +1,4 @@
+require "active_support"
 require "active_support/core_ext/hash"
 require "active_support/core_ext/string"
 
@@ -17,6 +18,7 @@ module Wrapbox
     :volumes,
     :placement_constraints,
     :placement_strategy,
+    :capacity_provider_strategy,
     :launch_type,
     :requires_compatibilities,
     :task_definition,
@@ -28,7 +30,12 @@ module Wrapbox
     :task_role_arn,
     :execution_role_arn,
     :keep_container,
-    :log_fetcher
+    :log_fetcher,
+    :tags,
+    :enable_ecs_managed_tags,
+    :propagate_tags,
+    :launch_instances,
+    :enable_execute_command,
   ) do
     def self.load_config(config)
       new(
@@ -46,6 +53,7 @@ module Wrapbox
         config["volumes"]&.map(&:deep_symbolize_keys) || [],
         config["placement_constraints"]&.map(&:deep_symbolize_keys) || [],
         config["placement_strategy"]&.map(&:deep_symbolize_keys) || [],
+        config["capacity_provider_strategy"]&.map(&:deep_symbolize_keys) || [],
         config["launch_type"],
         config["requires_compatibilities"] || ["EC2"],
         config["task_definition"]&.deep_symbolize_keys,
@@ -57,7 +65,12 @@ module Wrapbox
         config["task_role_arn"],
         config["execution_role_arn"],
         config["keep_container"],
-        config["log_fetcher"]&.deep_symbolize_keys
+        config["log_fetcher"]&.deep_symbolize_keys,
+        config["tags"],
+        config["enable_ecs_managed_tags"],
+        config["propagate_tags"],
+        config["launch_instances"]&.deep_symbolize_keys,
+        config["enable_execute_command"]
       )
     end
 
@@ -67,19 +80,23 @@ module Wrapbox
       super
     end
 
-    def build_runner(overrided_runner = nil)
+    def runner_class(overrided_runner = nil)
       r = overrided_runner || runner
       raise "#{r} is unsupported runner" unless AVAILABLE_RUNNERS.include?(r.to_sym)
       require "wrapbox/runner/#{r}"
-      Wrapbox::Runner.const_get(r.to_s.camelcase).new(to_h)
+      Wrapbox::Runner.const_get(r.to_s.camelcase)
     end
 
     def run(class_name, method_name, args, runner: nil, **options)
-      build_runner(runner).run(class_name, method_name, args, **options)
+      klass = runner_class(runner)
+      overridable_options, parameters = klass.split_overridable_options_and_parameters(options)
+      klass.new(to_h.merge(overridable_options)).run(class_name, method_name, args, **parameters)
     end
 
     def run_cmd(*cmd, runner: nil, **options)
-      build_runner(runner).run_cmd(*cmd, **options)
+      klass = runner_class(runner)
+      overridable_options, parameters = klass.split_overridable_options_and_parameters(options)
+      klass.new(to_h.merge(overridable_options)).run_cmd(*cmd, **parameters)
     end
   end
 end

data/lib/wrapbox/log_fetcher/awslogs.rb

@@ -27,6 +27,14 @@ module Wrapbox
 
       def run(task:)
         @loop_thread = Thread.start do
+          # It smees that task.contaienrs is empty
+          # if capacity_provider_strategy is specified and there are no remaining capacity
+          while task.containers.empty?
+            Wrapbox.logger.warn("The task has no containers, so fetch it again")
+            sleep 10
+            task = ecs_client.describe_tasks(cluster: task.cluster_arn, tasks: [task.task_arn]).tasks.first
+          end
+
           main_loop(task)
         end
       end
@@ -45,30 +53,34 @@ module Wrapbox
           log_group_name: @log_group,
           log_stream_names: log_stream_names,
           filter_pattern: @filter_pattern,
-          interleaved: true,
         }.compact
         @max_timestamp = ((Time.now.to_f - 120) * 1000).round
 
         until @stop do
           filter_log_opts[:start_time] = @max_timestamp + 1
-          resp = client.filter_log_events(filter_log_opts) rescue nil
-          resp&.each do |r|
-            r.events.each do |ev|
-              next if @displayed_event_ids.member?(ev.event_id)
-              display_message(ev)
-              @displayed_event_ids[ev.event_id] = ev.timestamp
-              @max_timestamp = ev.timestamp if @max_timestamp < ev.timestamp
+          begin
+            client.filter_log_events(filter_log_opts).each do |r|
+              r.events.each do |ev|
+                next if @displayed_event_ids.member?(ev.event_id)
+                display_message(ev)
+                @displayed_event_ids[ev.event_id] = ev.timestamp
+                @max_timestamp = ev.timestamp if @max_timestamp < ev.timestamp
+              end
             end
-          end
-          Thread.start do
+
             @displayed_event_ids.each do |event_id, ts|
               if ts < (Time.now.to_f - 600) * 1000
                 @displayed_event_ids.delete(event_id)
               end
             end
-          end.tap do
-            sleep @delay 
-          end.join
+          rescue Aws::CloudWatchLogs::Errors::ResourceNotFoundException
+            # Ignore the error because it is an error like "The specified log stream does not exist.",
+            # which occurs when the log stream hasn't been created yet, that is, the task hasn't started yet.
+          rescue Aws::CloudWatchLogs::Errors::ThrottlingException
+            Wrapbox.logger.warn("Failed to fetch logs due to Aws::CloudWatchLogs::Errors::ThrottlingException")
+          end
+
+          sleep @delay
         end
       end
 

data/lib/wrapbox/runner/docker.rb

@@ -4,6 +4,8 @@ require "docker"
 require "thor"
 require "shellwords"
 
+require "wrapbox"
+
 module Wrapbox
   module Runner
     class Docker
@@ -14,6 +16,17 @@ module Wrapbox
         :container_definition,
         :keep_container
 
+      def self.split_overridable_options_and_parameters(options)
+        opts = options.dup
+        overridable_options = {}
+        %i[keep_container].each do |key|
+          value = opts.delete(key)
+          overridable_options[key] = value if value
+        end
+
+        [overridable_options, opts]
+      end
+
       def initialize(options)
         @name = options[:name]
         @container_definitions = options[:container_definition] ? [options[:container_definition]] : options[:container_definitions]
@@ -136,6 +149,7 @@ module Wrapbox
         method_option :config_name, aliases: "-n", required: true, default: "default"
         method_option :cpu, type: :numeric
         method_option :memory, type: :numeric
+        method_option :working_directory, aliases: "-w", type: :string
         method_option :environments, aliases: "-e"
         method_option :ignore_signal, type: :boolean, default: false, desc: "Even if receive a signal (like TERM, INT, QUIT), Docker container continue running"
         method_option :verbose, aliases: "-v", type: :boolean, default: false, desc: "Verbose mode"
@@ -146,8 +160,8 @@ module Wrapbox
           environments = options[:environments].to_s.split(/,\s*/).map { |kv| kv.split("=") }.map do |k, v|
             {name: k, value: v}
           end
-          if options[:cpu] || options[:memory]
-            container_definition_overrides = {cpu: options[:cpu], memory: options[:memory]}.reject { |_, v| v.nil? }
+          if options[:cpu] || options[:memory] || options[:working_directory]
+            container_definition_overrides = {cpu: options[:cpu], memory: options[:memory], working_directory: options[:working_directory]}.reject { |_, v| v.nil? }
           else
             container_definition_overrides = {}
           end

data/lib/wrapbox/runner/ecs/instance_manager.rb

@@ -0,0 +1,92 @@
+require "aws-sdk-ec2"
+require "aws-sdk-ecs"
+
+module Wrapbox
+  module Runner
+    class Ecs
+      class InstanceManager
+        def initialize(cluster, region, launch_template:, instance_type: nil, tag_specifications: nil, wait_until_instance_terminated: true)
+          @cluster = cluster
+          @region = region
+          @launch_template = launch_template
+          @instance_type = instance_type
+          @tag_specifications = tag_specifications
+          @wait_until_instance_terminated = wait_until_instance_terminated
+          @queue = Queue.new
+          @instance_ids = []
+        end
+
+        def pop_ec2_instance_id
+          Wrapbox.logger.debug("Wait until a new container instance are registered in \"#{@cluster}\" cluster")
+          @queue.pop
+        end
+
+        def start_preparing_instances(count)
+          preparing_instance_ids = ec2_client.run_instances(
+            launch_template: @launch_template,
+            instance_type: @instance_type,
+            tag_specifications: @tag_specifications,
+            min_count: count,
+            max_count: count
+          ).instances.map(&:instance_id)
+          @instance_ids.concat(preparing_instance_ids)
+          ec2_client.wait_until(:instance_running, instance_ids: preparing_instance_ids)
+
+          waiter = Aws::Waiters::Waiter.new(
+            max_attempts: 40,
+            delay: 15,
+            poller: Aws::Waiters::Poller.new(
+              operation_name: :list_container_instances,
+              acceptors: [
+                {
+                  "expected" => true,
+                  "matcher" => "path",
+                  "state" => "success",
+                  "argument" => "length(container_instance_arns) > `0`"
+                }
+              ]
+            )
+          )
+
+          while preparing_instance_ids.size > 0
+            waiter.wait(client: ecs_client, params: { cluster: @cluster, filter: "ec2InstanceId in [#{preparing_instance_ids.join(",")}]" }).each do |resp|
+              ecs_client.describe_container_instances(cluster: @cluster, container_instances: resp.container_instance_arns).container_instances.each do |c|
+                preparing_instance_ids.delete(c.ec2_instance_id)
+                @queue << c.ec2_instance_id
+              end
+            end
+          end
+        end
+
+        def terminate_instance(instance_id)
+          ec2_client.terminate_instances(instance_ids: [instance_id])
+          if @wait_until_instance_terminated
+            ec2_client.wait_until(:instance_terminated, instance_ids: [instance_id])
+          end
+          @instance_ids.delete(instance_id)
+        end
+
+        def terminate_all_instances
+          # Duplicate @instance_ids because other threads can change it
+          remaining_instance_ids = @instance_ids.dup
+          return if remaining_instance_ids.empty?
+          ec2_client.terminate_instances(instance_ids: remaining_instance_ids)
+          if @wait_until_instance_terminated
+            ec2_client.wait_until(:instance_terminated, instance_ids: remaining_instance_ids)
+          end
+          @instance_ids.clear
+        end
+
+        private
+
+        def ecs_client
+          @ecs_client ||= Aws::ECS::Client.new({ region: @region }.reject { |_, v| v.nil? })
+        end
+
+        def ec2_client
+          @ec2_client ||= Aws::EC2::Client.new({ region: @region }.reject { |_, v| v.nil? })
+        end
+      end
+    end
+  end
+end

data/lib/wrapbox/runner/ecs/task_waiter.rb

@@ -0,0 +1,120 @@
+require "timeout"
+
+require "aws-sdk-ecs"
+
+module Wrapbox
+  module Runner
+    class Ecs
+      class TaskWaiter
+        MAX_DESCRIBABLE_TASK_COUNT = 100
+
+        class WaitFailure < StandardError; end
+        class TaskStopped < WaitFailure; end
+        class TaskMissing < WaitFailure; end
+        class UnknownFailure < WaitFailure; end
+        class WaitTimeout < WaitFailure; end
+
+        def initialize(cluster:, region:, delay:)
+          @cluster = cluster
+          @region = region
+          @task_arn_to_described_result = {}
+          @mutex = Mutex.new
+          @cv = ConditionVariable.new
+          Thread.new { update_described_results(delay) }
+        end
+
+        # @return Aws::ECS::Types::Task
+        def wait_task_running(task_arn, timeout: 0)
+          Timeout.timeout(timeout) do
+            loop do
+              result = describe_task(task_arn)
+              if result[:failure]
+                case result[:failure].reason
+                when "MISSING"
+                  raise TaskMissing
+                else
+                  raise UnknownFailure
+                end
+              end
+              raise TaskStopped if result[:task].last_status == "STOPPED"
+
+              return result[:task] if result[:task].last_status == "RUNNING"
+            end
+          end
+        rescue Timeout::Error
+          raise WaitTimeout
+        end
+
+        # @return Aws::ECS::Types::Task
+        def wait_task_stopped(task_arn, timeout: 0)
+          Timeout.timeout(timeout) do
+            result = nil
+            loop do
+              result = describe_task(task_arn)
+              if result[:failure]
+                case result[:failure].reason
+                when "MISSING"
+                  raise TaskMissing
+                else
+                  raise UnknownFailure
+                end
+              end
+
+              return result[:task] if result[:task].last_status == "STOPPED"
+            end
+          end
+        rescue Timeout::Error
+          raise WaitTimeout
+        end
+
+        private
+
+        def describe_task(task_arn)
+          @mutex.synchronize do
+            @task_arn_to_described_result[task_arn] = nil
+            @cv.wait(@mutex)
+            @task_arn_to_described_result[task_arn]
+          end
+        ensure
+          @mutex.synchronize do
+            @task_arn_to_described_result.delete(task_arn)
+          end
+        end
+
+        def update_described_results(interval)
+          loop do
+            @mutex.synchronize do
+              unless @task_arn_to_described_result.empty?
+                begin
+                  @task_arn_to_described_result.keys.each_slice(MAX_DESCRIBABLE_TASK_COUNT) do |task_arns|
+                    resp = ecs_client.describe_tasks(cluster: @cluster, tasks: task_arns)
+                    resp.tasks.each do |task|
+                      @task_arn_to_described_result[task.task_arn] = { task: task }
+                    end
+                    resp.failures.each do |failure|
+                      # failure.arn is like "arn:aws:ecs:<region>:<account-id>:task/<task-id>"
+                      # even if task_arn is like "arn:aws:ecs:<region>:<account-id>:task/<cluster>/<task-id>"
+                      prefix, suffix = failure.arn.split("/")
+                      task_arn = task_arns.find { |a| a.start_with?(prefix) && a.end_with?(suffix) }
+                      @task_arn_to_described_result[task_arn || failure.arn] = { failure: failure }
+                    end
+                  end
+
+                  @cv.broadcast
+                rescue Aws::ECS::Errors::ThrottlingException
+                  Wrapbox.logger.warn("Failed to describe tasks due to Aws::ECS::Errors::ThrottlingException")
+                end
+              end
+            end
+
+            sleep interval
+          end
+        end
+
+        def ecs_client
+          @ecs_client ||= Aws::ECS::Client.new({ region: @region }.reject { |_, v| v.nil? })
+        end
+      end
+    end
+  end
+end