elastic_whenever 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 279fa293930adedd6b35d4fbf629c8b647c09b35
-  data.tar.gz: d2949e35f69c75489f38fc9e9b45a655c06de5b4
+  metadata.gz: fdc3b1d145e38b2bd8850b9308b5317f6077c0cc
+  data.tar.gz: 49262310bd75b89f1cc22ef009380fd5c98d9e65
 SHA512:
-  metadata.gz: bdd1cf72a17f318c78ad1e27fb6340761e064ace66c4a45b8942437dc302a8a06b984a0cf16b95afad9199c13b9d650c8d56be5fbb29471d7afc33d2d5599301
-  data.tar.gz: 74528044ab14b01dfdf3c40910b2049ffae4b06c56476033d2374910e3a5c58e45793bb7a5f06f70f41a314d1dd6ecd2b2dc56414a5a8500489c30080c10ae6b
+  metadata.gz: 3ab0c5534ff5e58d532dac65846564787d3916645518dba404800072f61464ef037a6d2ef4a6e555b99ceb20841c81667ac2d769f7cdc9d4b86bff9a4b4fc7a7
+  data.tar.gz: ff7a4114ef6840ea85c780b8b7418896cae7523b4acbbc5680100cd77b4240c81257fd3cff63366fc21d788f41643f9ab66581659a2204bb64c8e718878912c0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Kazuma Watanabe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -1,4 +1,7 @@
 # Elastic Whenever
+[![Build Status](https://travis-ci.org/wata727/elastic_whenever.svg?branch=master)](https://travis-ci.org/wata727/elastic_whenever)
+[![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](LICENSE.txt)
+[![Gem Version](https://badge.fury.io/rb/elastic_whenever.svg)](https://badge.fury.io/rb/elastic_whenever)
 
 Manage ECS scheduled tasks like whenever gem.
 
@@ -67,6 +70,148 @@ cron(0 3 * * ? *) ecs-test example:2 cron bundle exec rake hoge:run
 ## [message] Run `elastic_whenever --help' for more options.
 ```
 
+## How it works
+Elastic Whenever creates CloudWatch Events as many as `every` block. The number of jobs declared in it corresponds to the target.
+
+```ruby
+every '0 0 * * *' do # scheduled task (identifier_68237a3b152a6c44359e1cf5cd8e7cf0def303d7)
+  rake "hoge:run"    # target for `identifier_68237a3b152a6c44359e1cf5cd8e7cf0def303d7`
+  command "awesome"  # target for `identifier_68237a3b152a6c44359e1cf5cd8e7cf0def303d7`
+end
+```
+
+The name of the scheduled task is the identifier passed in CLI and the digest value calculated from the command etc.
+Because CloudWatch Events rule names are unique across all clusters, you should not use the same identifier across different clusters.
+
+## Compatible with Whenever
+### `job_type` method is not supported
+Whenever supports custom job type using `job_type` method, but Elastic Whenever does not support it.
+
+```ruby
+# [warn] Skipping unsupported method: job_type
+job_type :awesome, '/usr/local/bin/awesome :task :fun_level'
+```
+
+### `env` method is not supported
+Whenever supports environment variables using `env` method, but Elastic Whenever does not support it.
+You should use task definitions to set environment variables.
+
+```ruby
+# [warn] Skipping unsupported method: env
+env "VERSION", "v1"
+```
+
+### `:job_template` option is not supported.
+Whenever has a template to describe as cron, but Elastic Whenever does not have the template.
+Therefore, `:job_template` option is ignored.
+
+```ruby
+set :job_template, "/bin/zsh -l -c ':job'" # ignored
+```
+
+### Behavior of frequency
+Elastic Whenever processes the frequency received by `every` block almost like whenever.
+
+```ruby
+# Whenever
+#   0 15 * * * /bin/bash -l -c 'cd /home/user/app && RAILS_ENV=production bundle exec rake hoge:run --silent'
+#
+# Elastic Whenever
+#   cron(0 15 * * ? *) ecs-test myapp:2 web bundle exec rake hoge:run --silent
+#
+every :day, at: "3:00" do
+  rake "hoge:run"
+end
+
+# Whenever
+#   0,10,20,30,40,50 * * * * /bin/bash -l -c 'awesome'
+#
+# Elastic Whenever
+#   cron(0,10,20,30,40,50 * * * ? *) ecs-test myapp:2 web awesome
+#
+every 10.minutes do
+  command "awesome"
+end
+```
+
+However, handling of the day of week is partially different because it follows the scheduled expression.
+
+```ruby
+# Whenever
+#   0 0 * * 1 /bin/bash -l -c 'awesome'
+#
+# Elastic Whenever
+#   cron(0 0 ? * 2 *) ecs-test myapp:2 web awesome
+#
+every :monday do
+  command "awesome"
+end
+```
+
+Therefore, the cron syntax is converted to scheduled tasks.
+
+```ruby
+# cron(0 0 ? * 2 *) ecs-test myapp:2 web awesome
+every "0 0 * * 1" do
+  command "awesome"
+end
+```
+
+Of course, you can write the scheduled expression.
+
+```ruby
+# cron(0 0 ? * 2 *) ecs-test myapp:2 web awesome
+every "0 0 ? * 2 *" do
+  command "awesome"
+end
+```
+
+#### `:reboot` option is not supported
+Whenever supports `:reboot` which is a function of cron, but Elastic Whenever does not support it.
+
+```ruby
+# [warn] `reboot` is not supported option. Ignore this task.
+every :reboot do
+  rake "hoge:run"
+end
+```
+
+### Behavior of bundle commands
+Whenever checks if the application uses bundler and automatically adds the prefix to commands.
+However, Elastic Whenever always adds the prefix on the premise that the application is using bundler.
+
+```ruby
+# Whenever
+#   With bundler    -> bundle exec rake hoge:run
+#   Without bundler -> rake hoge:run
+#
+# Elastic Whenever
+#   bundle exec rake hoge:run
+#
+rake "hoge:run"
+```
+
+If you don't want to add the prefix, set `bundle_command` to empty as follows:
+
+```ruby
+set :bundle_command, ""
+```
+
+### Drop support for for Rails 3 or below
+Whenever supports `runner` job with old Rails version, but Elastic Whenever supports Rails 4 and above only.
+
+```ruby
+# Whenever
+#   Before them -> script/runner Hoge.run
+#   Rails 3     -> script/rails runner Hoge.run
+#   Rails 4     -> bin/rails runner Hoge.run
+#
+# Elastic Whenever
+#   bin/rails runner Hoge.run
+#
+runner "Hoge.run"
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/elastic_whenever/cli.rb

@@ -36,7 +36,8 @@ module ElasticWhenever
         ERROR_EXIT_CODE
       rescue OptionParser::MissingArgument,
         Option::InvalidOptionException,
-        Schedule::InvalidScheduleException => exn
+        Schedule::InvalidScheduleException,
+        Task::Target::InvalidContainerException => exn
 
         Logger.instance.fail(exn.message)
         ERROR_EXIT_CODE
@@ -57,12 +58,7 @@ module ElasticWhenever
 
         clear_tasks(option) unless dry_run
         schedule.tasks.each do |task|
-          begin
-            rule = Task::Rule.convert(option, task, schedule.chronic_options)
-          rescue Task::Rule::UnsupportedOptionException => exn
-            Logger.instance.warn(exn.message)
-            next
-          end
+          rule = Task::Rule.convert(option, task)
           targets = task.commands.map do |command|
             Task::Target.new(
               option,

data/lib/elastic_whenever/schedule.rb

@@ -8,6 +8,47 @@ module ElasticWhenever
     attr_reader :bundle_command
 
     class InvalidScheduleException < StandardError; end
+    class UnsupportedFrequencyException < StandardError; end
+
+    module WheneverNumeric
+      refine Numeric do
+        def seconds
+          self
+        end
+        alias :second :seconds
+
+        def minutes
+          self * 60
+        end
+        alias :minute :minutes
+
+        def hours
+          (self * 60).minutes
+        end
+        alias :hour :hours
+
+        def days
+          (self * 24).hours
+        end
+        alias :day :days
+
+        def weeks
+          (self * 7).days
+        end
+        alias :week :weeks
+
+        def months
+          (self * 30).days
+        end
+        alias :month :months
+
+        def years
+          (self * 365.25).days
+        end
+        alias :year :years
+      end
+    end
+    using WheneverNumeric
 
     def initialize(file, variables)
       @environment = "production"
@@ -27,9 +68,11 @@ module ElasticWhenever
     end
 
     def every(frequency, options = {}, &block)
-      @tasks << Task.new(@environment, @bundle_command, frequency, options).tap do |task|
+      @tasks << Task.new(@environment, @bundle_command, schedule_expression(frequency, options)).tap do |task|
         task.instance_eval(&block)
       end
+    rescue UnsupportedFrequencyException => exn
+      Logger.instance.warn(exn.message)
     end
 
     def validate!
@@ -38,6 +81,83 @@ module ElasticWhenever
       raise InvalidScheduleException.new("You must set container") unless container
     end
 
+    def schedule_expression(frequency, options)
+      opts =  { :now => Time.new(2017, 12, 1, 0, 0, 0) }.merge(@chronic_options)
+      time = Chronic.parse(options[:at], opts) || Time.new(2017, 12, 1, 0, 0, 0)
+
+      case frequency
+      when 1.minute
+        "cron(* * * * ? *)"
+      when :hour, 1.hour
+        "cron(#{time.min} * * * ? *)"
+      when :day, 1.day
+        "cron(#{time.min} #{time.hour} * * ? *)"
+      when :month, 1.month
+        "cron(#{time.min} #{time.hour} #{time.day} * ? *)"
+      when :year, 1.year
+        "cron(#{time.min} #{time.hour} #{time.day} #{time.month} ? *)"
+      when :sunday
+        "cron(#{time.min} #{time.hour} ? * 1 *)"
+      when :monday
+        "cron(#{time.min} #{time.hour} ? * 2 *)"
+      when :tuesday
+        "cron(#{time.min} #{time.hour} ? * 3 *)"
+      when :wednesday
+        "cron(#{time.min} #{time.hour} ? * 4 *)"
+      when :thursday
+        "cron(#{time.min} #{time.hour} ? * 5 *)"
+      when :friday
+        "cron(#{time.min} #{time.hour} ? * 6 *)"
+      when :saturday
+        "cron(#{time.min} #{time.hour} ? * 7 *)"
+      when :weekend
+        "cron(#{time.min} #{time.hour} ? * 1,7 *)"
+      when :weekday
+        "cron(#{time.min} #{time.hour} ? * 2-6 *)"
+      when 1.second...1.minute
+        raise UnsupportedFrequencyException.new("Time must be in minutes or higher. Ignore this task.")
+      when 1.minute...1.hour
+        step = (frequency / 60).round
+        min = []
+        (60 % step == 0 ? 0 : step).step(59, step) { |i| min << i }
+        "cron(#{min.join(",")} * * * ? *)"
+      when 1.hour...1.day
+        step = (frequency / 60 / 60).round
+        hour = []
+        (24 % step == 0 ? 0 : step).step(23, step) { |i| hour << i }
+        "cron(#{time.min} #{hour.join(",")} * * ? *)"
+      when 1.day...1.month
+        step = (frequency / 24 / 60 / 60).round
+        day = []
+        (step <= 16 ? 1 : step).step(30, step) { |i| day << i }
+        "cron(#{time.min} #{time.hour} #{day.join(",")} * ? *)"
+      when 1.month...12.months
+        step = (frequency / 30 / 24 / 60 / 60).round
+        month = []
+        (step <= 6 ? 1 : step).step(12, step) { |i| month << i }
+        "cron(#{time.min} #{time.hour} #{time.day} #{month.join(",")} ? *)"
+      when 12.months...Float::INFINITY
+        raise UnsupportedFrequencyException.new("Time must be in months or lower. Ignore this task.")
+      # cron syntax
+      when /^((\*?[\d\/,\-]*)\s*){5}$/
+        min, hour, day, mon, week, year = frequency.split(" ")
+        # You can't specify the Day-of-month and Day-of-week fields in the same Cron expression.
+        # If you specify a value in one of the fields, you must use a ? (question mark) in the other.
+        week.gsub!("*", "?") if day != "?"
+        day.gsub!("*", "?") if week != "?"
+        # cron syntax:          sunday -> 0
+        # scheduled expression: sunday -> 1
+        week.gsub!(/(\d)/) { (Integer($1) + 1) % 7 }
+        year = year || "*"
+        "cron(#{min} #{hour} #{day} #{mon} #{week} #{year})"
+      # schedule expression syntax
+      when /^((\*?\??L?W?[\d\/,\-]*)\s*){6}$/
+        "cron(#{frequency})"
+      else
+        raise UnsupportedFrequencyException.new("`#{frequency}` is not supported option. Ignore this task.")
+      end
+    end
+
     def method_missing(name, *args)
       Logger.instance.warn("Skipping unsupported method: #{name}")
     end

data/lib/elastic_whenever/task.rb

@@ -1,14 +1,12 @@
 module ElasticWhenever
   class Task
     attr_reader :commands
-    attr_reader :frequency
-    attr_reader :options
+    attr_reader :expression
 
-    def initialize(environment, bundle_command, frequency, options = {})
+    def initialize(environment, bundle_command, expression)
       @environment = environment
       @bundle_command = bundle_command.split(" ")
-      @frequency = frequency
-      @options = options
+      @expression = expression
       @commands = []
     end
 

data/lib/elastic_whenever/task/definition.rb

@@ -16,10 +16,14 @@ module ElasticWhenever
         definition&.task_definition_arn
       end
 
+      def containers
+        definition&.container_definitions&.map(&:name)
+      end
+
       private
 
       attr_reader :client
       attr_reader :definition
     end
   end
-end
+end

data/lib/elastic_whenever/task/rule.rb

@@ -17,11 +17,11 @@ module ElasticWhenever
         end
       end
 
-      def self.convert(option, task, chronic_options)
+      def self.convert(option, task)
         self.new(
           option,
           name: rule_name(option.identifier, task.commands),
-          expression: schedule_expression(task.frequency, task.options, chronic_options)
+          expression: task.expression
         )
       end
 
@@ -51,56 +51,6 @@ module ElasticWhenever
         "#{identifier}_#{Digest::SHA1.hexdigest(commands.map { |command| command.join("-") }.join("-"))}"
       end
 
-      def self.schedule_expression(frequency, options, chronic_options)
-        time = Chronic.parse(options[:at], chronic_options) || Time.new(2017, 12, 1, 0, 0, 0)
-
-        case frequency
-        when :hour
-          "cron(#{time.min} * * * ? *)"
-        when :day
-          "cron(#{time.min} #{time.hour} * * ? *)"
-        when :month
-          "cron(#{time.min} #{time.hour} #{time.day} * ? *)"
-        when :year
-          "cron(#{time.min} #{time.hour} #{time.day} #{time.month} ? *)"
-        when :sunday
-          "cron(#{time.min} #{time.hour} ? * 1 *)"
-        when :monday
-          "cron(#{time.min} #{time.hour} ? * 2 *)"
-        when :tuesday
-          "cron(#{time.min} #{time.hour} ? * 3 *)"
-        when :wednesday
-          "cron(#{time.min} #{time.hour} ? * 4 *)"
-        when :thursday
-          "cron(#{time.min} #{time.hour} ? * 5 *)"
-        when :friday
-          "cron(#{time.min} #{time.hour} ? * 6 *)"
-        when :saturday
-          "cron(#{time.min} #{time.hour} ? * 7 *)"
-        when :weekend
-          "cron(#{time.min} #{time.hour} ? * 1,7 *)"
-        when :weekday
-          "cron(#{time.min} #{time.hour} ? * 2-6 *)"
-        # cron syntax
-        when /^((\*?[\d\/,\-]*)\s*){5}$/
-          min, hour, day, mon, week, year = frequency.split(" ")
-          # You can't specify the Day-of-month and Day-of-week fields in the same Cron expression.
-          # If you specify a value in one of the fields, you must use a ? (question mark) in the other.
-          week.gsub!("*", "?") if day != "?"
-          day.gsub!("*", "?") if week != "?"
-          # cron syntax:          sunday -> 0
-          # scheduled expression: sunday -> 1
-          week.gsub!(/(\d)/) { (Integer($1) + 1) % 7 }
-          year = year || "*"
-          "cron(#{min} #{hour} #{day} #{mon} #{week} #{year})"
-        # schedule expression syntax
-        when /^((\*?\??L?W?[\d\/,\-]*)\s*){6}$/
-          "cron(#{frequency})"
-        else
-          raise UnsupportedOptionException.new("`#{frequency}` is not supported option. Ignore this task.")
-        end
-      end
-
       attr_reader :client
     end
   end

data/lib/elastic_whenever/task/target.rb

@@ -6,6 +6,8 @@ module ElasticWhenever
       attr_reader :container
       attr_reader :commands
 
+      class InvalidContainerException < StandardError; end
+
       def self.fetch(option, rule)
         client = Aws::CloudWatchEvents::Client.new(option.aws_config)
         targets = client.list_targets_by_rule(rule: rule.name).targets
@@ -25,6 +27,10 @@ module ElasticWhenever
       end
 
       def initialize(option, cluster:, definition:, container:, commands:, rule:, role:)
+        unless definition.containers.include?(container)
+          raise InvalidContainerException.new("#{container} is invalid container. valid=#{definition.containers.join(",")}")
+        end
+
         @cluster = cluster
         @definition = definition
         @container = container
@@ -70,4 +76,4 @@ module ElasticWhenever
       attr_reader :client
     end
   end
-end
+end

data/lib/elastic_whenever/version.rb

@@ -1,3 +1,3 @@
 module ElasticWhenever
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elastic_whenever
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Kazuma Watanabe
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-21 00:00:00.000000000 Z
+date: 2017-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -120,6 +120,7 @@ files:
 - ".rspec"
 - ".travis.yml"
 - Gemfile
+- LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
@@ -157,7 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Manage ECS Scheduled Tasks like Whenever