xronor 0.1.0

data/lib/xronor/dsl/default.rb

@@ -0,0 +1,27 @@
+module Xronor
+  class DSL
+    class Default
+      DEFAULT_TIMEZONE = "UTC"
+
+      def initialize(&block)
+        @result = OpenStruct.new(
+          cron_timezone: DEFAULT_TIMEZONE,
+          prefix: "",
+          timezone: DEFAULT_TIMEZONE,
+        )
+
+        instance_eval(&block)
+      end
+
+      %i(cron_timezone prefix timezone).each do |key|
+        define_method(key) do |arg|
+          @result.send("#{key}=", arg)
+        end
+      end
+
+      def result
+        @result
+      end
+    end
+  end
+end

data/lib/xronor/dsl/job.rb

@@ -0,0 +1,66 @@
+module Xronor
+  class DSL
+    class Job
+      include Xronor::DSL::Checker
+
+      def initialize(frequency, options, &block)
+        @frequency = frequency
+        @options = options
+
+        schedule = case frequency
+                   when String # cron expression
+                     frequency
+                   when Symbol, Numeric # DSL (:hour, 1.min, 1.hour, ...)
+                     Xronor::DSL::ScheduleConverter.convert(frequency, options)
+                   else
+                     raise ArgumentError, "Invalid frequency #{frequency}"
+                   end
+
+        @result = OpenStruct.new(
+          description: nil,
+          name: "",
+          schedule: schedule,
+          command: "",
+        )
+
+        instance_eval(&block)
+      end
+
+      %i(description name).each do |key|
+        define_method(key) do |arg|
+          @result.send("#{key}=", arg)
+        end
+      end
+
+      def process_template(template, options)
+        template.gsub(/:\w+/) do |key|
+          before_and_after = [$`[-1..-1], $'[0..0]]
+          option = options[key.sub(':', '').to_sym] || key
+
+          if before_and_after.all? { |c| c == "'" }
+            escape_single_quotes(option)
+          elsif before_and_after.all? { |c| c == '"' }
+            escape_double_quotes(option)
+          else
+            option
+          end
+        end.gsub(/\s+/m, " ").strip
+      end
+
+      def result
+        required(:name, @result.name)
+        @result
+      end
+
+      private
+
+      def escape_single_quotes(str)
+        str.gsub(/'/) { "'\\''" }
+      end
+
+      def escape_double_quotes(str)
+        str.gsub(/"/) { '\"' }
+      end
+    end
+  end
+end

data/lib/xronor/dsl/numeric_seconds.rb

@@ -0,0 +1,75 @@
+# This file is derived from Whenever, Copyright (c) 2017 Javan Makhmali
+# Original code:
+# https://github.com/javan/whenever/blob/1dcb91484e6f1ee91c9272daccbe84111754102b/lib/whenever/numeric_seconds.rb
+#
+# 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.
+#
+# Modifications are Copyright 2017 Daisuke Fujita. License under the MIT License.
+
+module Xronor
+  class DSL
+    class NumericSeconds
+      def self.seconds(number, units)
+        self.new(number).send(units)
+      end
+
+      def initialize(number)
+        @number = number.to_i
+      end
+
+      def seconds
+        @number
+      end
+      alias :second :seconds
+
+      def minutes
+        @number * 60
+      end
+      alias :minute :minutes
+
+      def hours
+        @number * 60 * 60
+      end
+      alias :hour :hours
+
+      def days
+        @number * 60 * 60 * 24
+      end
+      alias :day :days
+
+      def weeks
+        @number * 60 * 60 * 24 * 7
+      end
+      alias :week :weeks
+
+      def months
+        @number * 60 * 60 * 24 * 30
+      end
+      alias :month :months
+
+      def years
+        @number * 60 * 60 * 24 * 365 + 60 * 60 * 6 # consider leap year
+      end
+      alias :year :years
+    end
+  end
+end

data/lib/xronor/dsl/schedule_converter.rb

@@ -0,0 +1,147 @@
+# Part of logic in this file is derived from Whenever, Copyright (c) 2017 Javan Makhmali
+# Original code:
+# https://github.com/javan/whenever/blob/1dcb91484e6f1ee91c9272daccbe84111754102b/lib/whenever/cron.rb
+#
+# 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.
+#
+# Modifications are Copyright 2017 Daisuke Fujita. License under the MIT License.
+
+module Xronor
+  class DSL
+    class ScheduleConverter
+      WEEKDAYS = %i(sunday monday tuesday wednesday thursday friday saturday)
+
+      class << self
+        def convert(frequency, options)
+          self.new(frequency, options).convert
+        end
+      end
+
+      def initialize(frequency, options)
+        @frequency = frequency
+        @options = options
+      end
+
+      def convert
+        cron_at, dow_diff = case @options[:at]
+                            when String
+                              parse_and_convert_time
+                            when Numeric
+                              [@options[:at], 0]
+                            else
+                              [0, 0]
+                            end
+
+        if WEEKDAYS.include?(@frequency) # :sunday, :monday, ..., :saturday
+          return cron_weekly(cron_at, dow_diff)
+        end
+
+        shortcut = case @frequency
+                   when Numeric
+                     @frequency
+                   when :minute
+                     Xronor::DSL.seconds(1, :minute)
+                   when :hour
+                     Xronor::DSL.seconds(1, :hour)
+                   when :day
+                     Xronor::DSL.seconds(1, :day)
+                   end
+
+        raise ArgumentError, "Invalid frequency #{@frequency}" if !shortcut.is_a?(Numeric)
+
+        cron(shortcut, cron_at)
+      end
+
+      private
+
+      def comma_separated_timing(frequency, max, start = 0)
+        return start     if frequency.nil? || frequency == "" || frequency == 0
+        return "*"       if frequency == 1
+        return frequency if frequency > (max * 0.5) .ceil
+
+        original_start = start
+
+        start += frequency unless (max + 1).modulo(frequency).zero? || start > 0
+        output = (start..max).step(frequency).to_a
+
+        max_occurances = (max.to_f  / (frequency.to_f)).round
+        max_occurances += 1 if original_start.zero?
+
+        output[0, max_occurances].join(',')
+      end
+
+      def cron(shortcut, cron_at)
+        digits = ["*", "*", "*", "*", "*"]
+
+        case shortcut
+        when Xronor::DSL.seconds(0, :second)...Xronor::DSL.seconds(1, :minute)
+          raise ArgumentError, "Time must be in minutes or higher"
+        when Xronor::DSL.seconds(1, :minute)...Xronor::DSL.seconds(1, :hour)
+          min_frequency = shortcut / 60
+          digits[0] = comma_separated_timing(min_frequency, 59, cron_at.is_a?(Time) ? cron_at.min : 0)
+        when Xronor::DSL.seconds(1, :hour)...Xronor::DSL.seconds(1, :day)
+          hour_frequency = (shortcut / 60 / 60).round
+          digits[0] = cron_at.is_a?(Time) ? cron_at.min : cron_at
+          digits[1] = comma_separated_timing(hour_frequency, 23, cron_at.is_a?(Time) ? cron_at.hour : 0)
+        when Xronor::DSL.seconds(1, :day)...Xronor::DSL.seconds(1, :month)
+          day_frequency = (shortcut / 24 / 60 / 60).round
+          digits[0] = cron_at.is_a?(Time) ? cron_at.min : 0
+          digits[1] = cron_at.is_a?(Time) ? cron_at.hour : cron_at
+          digits[2] = comma_separated_timing(day_frequency, 31, 1)
+        end
+
+        digits.join(" ")
+      end
+
+      def cron_weekly(cron_at, dow_diff)
+        dow = WEEKDAYS.index(@frequency)
+        dow += dow_diff
+
+        case dow
+        when -1 # Sunday -> Saturday
+          dow = 6
+        when 7  # Saturday -> Sunday
+          dow = 0
+        end
+
+        [
+          cron_at.is_a?(Time) ? cron_at.min : "0",
+          cron_at.is_a?(Time) ? cron_at.hour : "0",
+          "*",
+          "*",
+          dow,
+        ].join(" ")
+      end
+
+      def parse_and_convert_time
+        original_time_class = Chronic.time_class
+        Time.zone = @options[:timezone]
+        Chronic.time_class = Time.zone
+        local_at = Chronic.parse(@options[:at])
+        cron_at = local_at.in_time_zone(@options[:cron_timezone])
+        Chronic.time_class = original_time_class
+
+        return cron_at, (cron_at.wday - local_at.wday)
+      end
+    end
+  end
+end

data/lib/xronor/dsl.rb

@@ -0,0 +1,63 @@
+module Xronor
+  class DSL
+    DEFAULT_PREFIX = "scheduler-"
+    DEFAULT_TIMEZONE = "UTC"
+    DEFAULT_CRON_TIMEZONE = "UTC"
+    DEFAULT_JOB_TEMPLATE = ":job"
+
+    class DuplicatedError < StandardError; end
+
+    class << self
+      def eval(body)
+        self.new(body)
+      end
+
+      def seconds(number, units)
+        Xronor::DSL::NumericSeconds.seconds(number, units)
+      end
+    end
+
+    def initialize(body)
+      @result = OpenStruct.new(
+        jobs: {},
+        options: {
+          prefix: DEFAULT_PREFIX,
+          timezone: DEFAULT_TIMEZONE,
+          cron_timezone: DEFAULT_CRON_TIMEZONE,
+          job_template: DEFAULT_JOB_TEMPLATE,
+        },
+      )
+
+      instance_eval(body)
+    end
+
+    def default(&block)
+      @result.options.merge!(Xronor::DSL::Default.new(&block).result.to_h)
+    end
+
+    def every(frequency, options = {}, &block)
+      job = Xronor::DSL::Job.new(frequency, @result.options.merge(options), &block).result
+      raise Xronor::DSL::DuplicatedError, "Job \"#{job.name}\" already exists" if @result.jobs[job.name]
+      @result.jobs[job.name] = job
+    end
+
+    def job_template(template)
+      @result.options[:job_template] = template
+    end
+
+    def job_type(name, template)
+      Xronor::DSL::Job.class_eval do
+        define_method(name) do |task, *args|
+          options = { task: task }
+          options.merge!(args[0]) if args[0].is_a? Hash
+          job = process_template(template, options)
+          @result.command = process_template(@options[:job_template], options.merge({ job: job }))
+        end
+      end
+    end
+
+    def result
+      @result
+    end
+  end
+end

data/lib/xronor/generator/cloud_watch_events.rb

@@ -0,0 +1,77 @@
+module Xronor
+  module Generator
+    class CloudWatchEvents
+      class << self
+        def generate(filename, options)
+          jobs = Xronor::Parser.parse(filename)
+          function_arn = lambda.retrieve_function_arn(options[:function])
+
+          current_jobs = cwe.list_jobs(options[:prefix])
+          add_jobs, delete_jobs = compare_jobs(options[:prefix], current_jobs, jobs)
+
+          added_rule_arns = add_jobs.map do |job|
+            if options[:dry_run]
+              puts "[DRYRUN] #{job.name} will be registered to CloudWatch Events"
+            else
+              arn = cwe.register_job(
+                job,
+                options[:prefix],
+                options[:cluster],
+                options[:task_definition],
+                options[:container],
+                function_arn,
+              )
+              puts "Registered #{arn}"
+              arn
+            end
+          end
+
+          if options[:dry_run]
+          else
+            dynamodb.sync_rule_arns(options[:table], added_rule_arns, [])
+          end
+
+          delete_jobs.each do |job|
+            if options[:dry_run]
+              puts "[DRYRUN] #{job} will be deregistered from CloudWatch Events"
+            else
+              cwe.deregister_job(job)
+              puts "Deregistered #{job}"
+            end
+          end
+        end
+
+        private
+
+        def compare_jobs(prefix, current_jobs, next_jobs)
+          add_jobs, delete_jobs = [], []
+          next_job_names = next_jobs.map do |job|
+            job.cloud_watch_rule_name(prefix)
+          end
+
+          next_jobs.each do |job|
+            add_jobs << job unless current_jobs.include?(job.cloud_watch_rule_name(prefix))
+          end
+
+          current_jobs.each do |job|
+            delete_jobs << job unless next_job_names.include?(job)
+          end
+
+          return add_jobs, delete_jobs
+        end
+
+        def cwe
+          @cwe ||= Xronor::AWS::CloudWatchEvents.new
+        end
+
+        def dynamodb
+          @dynamodb ||= Xronor::AWS::DynamoDB.new
+        end
+
+        def lambda
+          @lambda ||= Xronor::AWS::Lambda.new
+        end
+      end
+    end
+  end
+end

data/lib/xronor/generator/crontab.rb

@@ -0,0 +1,18 @@
+module Xronor
+  module Generator
+    class Crontab
+      class << self
+        def generate(filename, options)
+          jobs = Xronor::Parser.parse(filename)
+
+          jobs.map do |job|
+            <<-EOS
+# #{job.name} - #{job.description}
+#{[job.schedule, job.command].join(" ")}
+EOS
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/xronor/generator/erb.rb

@@ -0,0 +1,24 @@
+module Xronor
+  module Generator
+    class ERB
+      class << self
+        def generate_all_in_one(filename, options)
+          @jobs = Xronor::Parser.parse(filename)
+          erb = open(options[:template]).read
+          ::ERB.new(erb, nil, "-").result(binding)
+        end
+
+        def generate_per_job(filename, options)
+          jobs = Xronor::Parser.parse(filename)
+          erb = open(options[:template]).read
+
+          jobs.inject({}) do |result, job|
+            @job = job
+            result[job.name.gsub(/[^\.\-_A-Za-z0-9]/, "_").downcase] = ::ERB.new(erb, nil, "-").result(binding)
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xronor/job.rb

@@ -0,0 +1,44 @@
+module Xronor
+  class Job
+    DOM_INDEX = 2
+    DOW_INDEX = 4
+
+    def initialize(name, description, schedule, command)
+      @name = name
+      @description = description
+      @schedule = schedule
+      @command = command
+    end
+
+    attr_reader :command, :description, :name, :schedule
+
+    def cloud_watch_schedule
+      cron_fields = @schedule.split(" ")
+
+      if cron_fields[DOM_INDEX] == "*" && cron_fields[DOW_INDEX] == "*"
+        cron_fields[DOW_INDEX] = "?"
+      else
+        cron_fields[DOM_INDEX] = "?" if cron_fields[DOM_INDEX] == "*"
+
+        if cron_fields[DOW_INDEX] == "*"
+          cron_fields[DOW_INDEX] = "?"
+        else
+          cron_fields[DOW_INDEX] = cron_fields[DOW_INDEX].to_i + 1
+        end
+      end
+
+      cron_fields << "*" # Year
+      "cron(#{cron_fields.join(" ")})"
+    end
+
+    def cloud_watch_rule_name(prefix)
+      "#{prefix}#{@name}-#{hashcode}".gsub(/[^\.\-_A-Za-z0-9]/, "-").downcase
+    end
+
+    private
+
+    def hashcode
+      @hashcode ||= OpenSSL::Digest::SHA256.hexdigest("#{@name}\t#{@description}\t#{@schedule}\t#{@command}")[0..12]
+    end
+  end
+end

data/lib/xronor/parser.rb

@@ -0,0 +1,13 @@
+module Xronor
+  class Parser
+    def self.parse(filename)
+      body = open(filename).read
+      result = Xronor::DSL.eval(body).result
+
+      result.jobs.values.map do |job|
+        job.description ||= job.name
+        Xronor::Job.new(job.name, job.description, job.schedule, job.command)
+      end
+    end
+  end
+end

data/lib/xronor/version.rb

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

data/lib/xronor.rb

@@ -0,0 +1,30 @@
+require "aws-sdk-core"
+require "active_support/core_ext/time"
+require "chronic"
+require "erb"
+require "openssl"
+require "optparse"
+require "shellwords"
+require "thor"
+
+require "xronor/aws/cloud_watch_events"
+require "xronor/aws/dynamo_db"
+require "xronor/aws/lambda"
+require "xronor/cli"
+require "xronor/core_ext/numeric"
+require "xronor/dsl"
+require "xronor/dsl/checker"
+require "xronor/dsl/default"
+require "xronor/dsl/job"
+require "xronor/dsl/numeric_seconds"
+require "xronor/dsl/schedule_converter"
+require "xronor/generator/crontab"
+require "xronor/generator/cloud_watch_events"
+require "xronor/generator/erb"
+require "xronor/job"
+require "xronor/parser"
+require "xronor/version"
+
+module Xronor
+
+end

data/xronor.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'xronor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "xronor"
+  spec.version       = Xronor::VERSION
+  spec.authors       = ["Daisuke Fujita"]
+  spec.email         = ["dtanshi45@gmail.com"]
+
+  spec.summary       = %q{Whenever DSL -> CloudWatch Events Schedule Rule & ECS Task Parameter}
+  spec.description   = %q{Convert Whenever DSL to CloudWatch Events Schedule Rule to invoke job on ECS}
+  spec.homepage      = "https://github.com/dtan4/xronor"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", "~> 5.0.2"
+  spec.add_dependency "aws-sdk", "~> 2.8.7"
+  spec.add_dependency "chronic", "~> 0.10"
+  spec.add_dependency "thor", "~> 0.19"
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end