lambda_whenever 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f2de4e951f291bea6c0661284733bc2ecc2f7f2556d0ec2c55af15666cbbe2d6
+  data.tar.gz: 7d8a1abe7a3c1429479dd43f6972bb9f964614192caaaf2d7b9509854827f41e
+SHA512:
+  metadata.gz: db1740b27b33eb0341f5616e31fdb8263ed59670f3a3a3f8ebe304934b4a0e20bbfd60c602014d9f4992f63089e118daa4fcd890f7f94c16a56f0cf01048c4df
+  data.tar.gz: 981e2ec5f416996265692bdd7b3fa7e83cba716e3958ea7d23ec568a5f00c3d02e2a1951354e49139854c81c24629a192450b18767f23fb1c4ac332b72a45a5d

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 toshichanapp
+
+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

@@ -0,0 +1,231 @@
+# LambdaWhenever
+
+`lambda_whenever` is a Ruby gem that allows you to create schedules with AWS EventBridge Scheduler targeting Lambda functions using the same syntax as the `whenever` gem.
+This gem simplifies the management of cron job configurations and enables event-driven batch processing.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lambda_whenever'
+```
+
+Or install it manually with Bundler in your Gemfile:
+
+```shell
+$ gem install lambda_whenever
+```
+
+## Usage
+
+You can use it almost like Whenever. However, please note that you must specify a `--lambda-name` and `--iam-role`.
+
+```shell
+$ lambda_whenever --help
+Usage: lambda_whenever [options]
+        --dryrun                     dry-run
+        --update                     Creates and deletes tasks as needed by schedule file
+    -c, --clear                      Clear scheduled tasks
+    -l, --list                       List scheduled tasks
+    -v, --version                    Print version
+    -s, --set variables              Example: --set 'environment=staging'
+        --lambda-name name           Lambda function name
+        --scheduler-group group_name Optionally specify event bridge scheduler group name
+    -f, --file schedule_file         Default: config/schedule.rb
+        --iam-role name              IAM role name used by EventBridgeScheduler.
+        --rule-state state           The state of the EventBridgeScheduler Rule. Default: ENABLED
+        --region region              AWS region
+    -V, --verbose                    Run rake jobs without --silent
+```
+
+### Setting Variables
+
+Lambda Whenever supports setting variables via the `--set` option, similar to [how Whenever does](https://github.com/javan/whenever/wiki/Setting-variables-on-the-fly).
+
+Example:
+
+```shell
+lambda_whenever --set 'environment=staging&some_var=foo'
+```
+
+```ruby
+if @environment == 'staging'
+  every '0 1 * * *' do
+    rake 'some_task_on_staging'
+  end
+elsif @some_var == 'foo'
+  every '0 10 * * *' do
+    rake 'some_task'
+  end
+end
+```
+
+The `@environment` variable defaults to `"production"`.
+
+## How It Works
+
+Lambda Whenever creates an EventBridge Scheduler schedule for each `every` block. Each schedule can have multiple commands.
+For example, the following input will generate one schedule with two commands:
+
+```ruby
+every '0 0 * * *' do
+  rake "hoge:run"
+  command "echo 'you can use raw cron syntax too'"
+end
+```
+
+This will result in:
+
+```shell
+cron(0 0 * * ? *) { commands: [["bundle", "exec", "rake", "hoge:run", "--silent"], ["echo", "'you", "can", "use", "raw", "cron", "syntax", "too'"]] }
+```
+
+In this example, one EventBridge Scheduler schedule is created, containing both the rake task and the command.
+The scheduled task's name is a digest value calculated from an cron expression, commands, and other parameters.
+
+## Prerequisites
+
+Before using this gem, ensure that you have the necessary IAM policies set up for EventBridge to invoke your Lambda functions.
+
+### IAM Policies for Executing the Gem
+
+To use this gem, the executing entity (e.g., GitHub Actions, CI/CD pipelines, or other automated systems)
+must have the necessary IAM policies to register schedules with EventBridge and obtain Lambda ARNs.
+The following policy grants the required permissions:
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": [
+        "scheduler:CreateScheduleGroup",
+        "scheduler:ListSchedules",
+        "scheduler:CreateSchedule",
+        "scheduler:DeleteSchedule",
+        "scheduler:UpdateSchedule",
+        "lambda:ListFunctions",
+        "lambda:GetFunction"
+      ],
+      "Resource": "*"
+    }
+  ]
+}
+```
+
+### Assume Role Policy for EventBridge
+
+You need an IAM role that allows EventBridge to assume the role and invoke your Lambda functions.
+The following policy should be attached to the role:
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Principal": {
+        "Service": "scheduler.amazonaws.com"
+      },
+      "Action": "sts:AssumeRole",
+      "Condition": {
+        "StringEquals": {
+          "aws:SourceAccount": "<your account id>"
+        }
+      }
+    }
+  ]
+}
+```
+
+### Execute Lambda Policy
+
+You also need a policy that allows EventBridge to execute your Lambda functions. Attach the following policy to the role:
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": "lambda:InvokeFunction",
+      "Resource": [
+        "<your lambda arn>:*",
+        "<your lambda arn>"
+      ]
+    }
+  ]
+}
+```
+
+## Compatibility with Whenever
+
+### Timezone Configuration
+
+In `lambda_whenever`, setting the timezone is slightly different from the traditional `whenever` gem.
+Instead of using `env "CRON_TZ", <zone>`, you should use the `set :timezone, <zone>` syntax to specify the timezone for your scheduled tasks.
+
+Example:
+
+```ruby
+set :timezone, "Asia/Tokyo"
+```
+
+### Methods
+
+Whenever supports custom job types with `job_type`, `env`, and `job_template` methods, but Lambda Whenever does not support these.
+
+### mailto
+
+Whenever supports the `mailto` method, but Lambda Whenever does not.
+Amazon EventBridge Scheduler does not natively support email notifications.
+As a result, the `mailto` option is not available in this gem.
+
+### Frequency
+
+Lambda Whenever processes the frequency passed to the `every` block similarly to Whenever.
+
+#### `:reboot`
+
+Whenever supports `:reboot` as a cron option, but Lambda Whenever does not support it.
+
+### Bundle Commands
+
+Whenever checks if the application uses Bundler and automatically adds a prefix to commands.
+However, Lambda Whenever always adds a prefix, assuming the application is using Bundler.
+
+```ruby
+# Whenever
+#   With bundler    -> bundle exec rake hoge:run
+#   Without bundler -> rake hoge:run
+#
+# Lambda Whenever
+#   bundle exec rake hoge:run
+#
+rake "hoge:run"
+```
+
+If you don't want to add the prefix, set `bundle_command` to an empty string as follows:
+
+```ruby
+set :bundle_command, ""
+```
+
+## 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.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/toshichanapp/lambda_whenever](https://github.com/toshichanapp/lambda_whenever).
+
+## License
+
+The gem is available as open-source under the terms of the MIT License.
+
+## Acknowledgement
+
+This gem is inspired by and built upon the work of the [whenever](https://github.com/javan/whenever) and [elastic_whenever](https://github.com/wata727/elastic_whenever) gems. We would like to express our gratitude to the developers and contributors of these projects for their foundational work and contributions to the Ruby community.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/exe/lambda_whenever_dev

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "lambda_whenever"
+
+exit LambdaWhenever::CLI.new(ARGV).run

data/lib/lambda_whenever/cli.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module LambdaWhenever
+  # The CLI class handles command-line interface interactions for the Lambda Whenever tool.
+  class CLI
+    SUCCESS_EXIT_CODE = 0
+    ERROR_EXIT_CODE = 1
+
+    attr_reader :args, :option
+
+    def initialize(args)
+      @args = args
+      @option = Option.new(args)
+    end
+
+    def run
+      case option.mode
+      when Option::DRYRUN_MODE
+        option.validate!
+        print_tasks
+        Logger.instance.message("Above is your schedule file converted to scheduled tasks; your scheduled tasks was not updated.")
+        Logger.instance.message("Run `lambda_whenever --help' for more options.")
+      when Option::UPDATE_MODE
+        option.validate!
+        with_concurrent_modification_handling do
+          update_eb_schedules
+        end
+        Logger.instance.log("write", "scheduled tasks updated")
+      when Option::CLEAR_MODE
+        with_concurrent_modification_handling do
+          clear_tasks
+        end
+        Logger.instance.log("write", "scheduled tasks cleared")
+      when Option::LIST_MODE
+        list_tasks
+        Logger.instance.message("Above is your scheduled tasks.")
+      when Option::PRINT_VERSION_MODE
+        print_version
+      end
+
+      SUCCESS_EXIT_CODE
+    rescue Aws::Errors::MissingRegionError
+      Logger.instance.fail("missing region error occurred; please use `--region` option or export `AWS_REGION` environment variable.")
+      ERROR_EXIT_CODE
+    rescue Aws::Errors::MissingCredentialsError
+      Logger.instance.fail("missing credential error occurred; please specify it with arguments, use shared credentials, or export `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` environment variable")
+      ERROR_EXIT_CODE
+    rescue OptionParser::MissingArgument,
+           Option::InvalidOptionException => e
+
+      Logger.instance.fail(e.message)
+      ERROR_EXIT_CODE
+    end
+
+    private
+
+    def update_eb_schedules
+      schedule = Schedule.new(option.schedule_file, option.verbose, option.variables)
+      scheduler = EventBridgeScheduler.new(option.scheduler_client, schedule.timezone)
+      scheduler.create_schedule_group(option.scheduler_group)
+      scheduler.clean_up_schedules(option.scheduler_group)
+
+      lambda_arn = TargetLambda.fetch_arn(option.lambda_name, option.lambda_client)
+      schedule.tasks.map do |task|
+        target = TargetLambda.new(arn: lambda_arn, task: task)
+
+        scheduler.create_schedule(target, option)
+      end
+    end
+
+    def clear_tasks
+      scheduler = EventBridgeScheduler.new(option.scheduler_client)
+      scheduler.clean_up_schedules(option.scheduler_group)
+    end
+
+    def list_tasks
+      scheduler = EventBridgeScheduler.new(option.scheduler_client)
+      scheduler.list_schedules(option.scheduler_group)
+    end
+
+    def print_version
+      puts "Lambda Whenever v#{LambdaWhenever::VERSION}"
+    end
+
+    def print_tasks
+      schedule = Schedule.new(option.schedule_file, option.verbose, option.variables)
+      schedule.print_tasks
+    end
+
+    def with_concurrent_modification_handling
+      Retryable.retryable(
+        tries: 5,
+        on: Aws::Scheduler::Errors::ConflictException,
+        sleep: ->(_n) { rand(1..10) }
+      ) do |retries, _exn|
+        Logger.instance.warn("concurrent modification detected; Retrying...") if retries.positive?
+        yield
+      end
+    end
+  end
+end

data/lib/lambda_whenever/event_bridge_scheduler.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module LambdaWhenever
+  # The EventBridgeScheduler class is responsible for managing schedules in AWS EventBridge.
+  class EventBridgeScheduler
+    attr_reader :timezone
+
+    def initialize(client, timezone = "UTC")
+      @scheduler_client = client
+      @timezone = timezone
+    end
+
+    def list_schedules(group_name)
+      Logger.instance.message("Schedules in group '#{group_name}':")
+      response = @scheduler_client.list_schedules({ group_name: group_name })
+      response.schedules.each do |schedule|
+        detail = @scheduler_client.get_schedule({ group_name: group_name, name: schedule.name })
+        puts "#{schedule.state} #{schedule.name} #{detail.schedule_expression} #{detail.description}"
+      end
+    end
+
+    def create_schedule_group(group_name)
+      @scheduler_client.create_schedule_group({ name: group_name })
+      puts "Schedule group '#{group_name}' created."
+    rescue Aws::Scheduler::Errors::ConflictException
+      puts "Schedule group '#{group_name}' already exists."
+    end
+
+    # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Scheduler/Client.html#create_schedule-instance_method
+    def create_schedule(target, option)
+      task = target.task
+      @scheduler_client.create_schedule({
+                                          name: schedule_name(task, option),
+                                          schedule_expression: task.expression,
+                                          schedule_expression_timezone: timezone,
+                                          flexible_time_window: {
+                                            maximum_window_in_minutes: 5,
+                                            mode: "FLEXIBLE"
+                                          },
+                                          target: {
+                                            arn: target.arn,
+                                            role_arn: IamRole.new(option).arn,
+                                            input: target.input
+                                          },
+                                          group_name: option.scheduler_group,
+                                          state: option.rule_state,
+                                          description: schedule_description(task)
+                                        })
+    end
+
+    def schedule_name(task, option)
+      Digest::SHA1.hexdigest([option.key, task.expression, *task.commands].join("-")).to_s[0, 64]
+    end
+
+    def schedule_description(task)
+      task.commands.to_s
+    end
+
+    def clean_up_schedules(schedule_group)
+      response = @scheduler_client.list_schedules({ group_name: schedule_group })
+      response.schedules.each do |schedule|
+        @scheduler_client.delete_schedule({
+                                            name: schedule.name,
+                                            group_name: schedule_group
+                                          })
+      end
+    rescue Aws::Scheduler::Errors::ResourceNotFoundException
+      puts "Schedule group '#{schedule_group}' does not exist."
+    end
+  end
+end

data/lib/lambda_whenever/iam_role.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module LambdaWhenever
+  # The IamRole class is responsible for interacting with AWS IAM roles.
+  class IamRole
+    def initialize(option)
+      client = option.iam_client
+      @resource = Aws::IAM::Resource.new(client: client)
+      @role_name = option.iam_role
+      @role = resource.role(@role_name)
+    end
+
+    def arn
+      role&.arn
+    end
+
+    def exists?
+      !!arn
+    rescue Aws::IAM::Errors::NoSuchEntity
+      false
+    end
+
+    private
+
+    attr_reader :resource, :role
+  end
+end

data/lib/lambda_whenever/logger.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module LambdaWhenever
+  class Logger
+    include Singleton
+
+    def fail(message)
+      Kernel.warn "[fail] #{message}"
+    end
+
+    def warn(message)
+      Kernel.warn "[warn] #{message}"
+    end
+
+    def log(event, message)
+      puts "[#{event}] #{message}"
+    end
+
+    def message(message)
+      puts "## [message] #{message}"
+    end
+  end
+end

data/lib/lambda_whenever/option.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module LambdaWhenever
+  # The Option class handles parsing and validation of command-line options.
+  class Option
+    POSSIBLE_RULE_STATES = %w[ENABLED DISABLED].freeze
+
+    DRYRUN_MODE = 1
+    UPDATE_MODE = 2
+    CLEAR_MODE = 3
+    LIST_MODE = 4
+    PRINT_VERSION_MODE = 5
+
+    attr_reader :mode, :verbose, :variables, :schedule_file, :iam_role, :rule_state,
+                :lambda_name, :scheduler_group
+
+    class InvalidOptionException < StandardError; end
+
+    def initialize(args)
+      @mode = DRYRUN_MODE
+      @verbose = false
+      @variables = []
+      @schedule_file = "config/schedule.rb"
+      @iam_role = nil
+      @rule_state = "ENABLED"
+      @lambda_name = nil
+      @scheduler_group = "lambda-whenever-dev-group"
+      @region = nil
+
+      OptionParser.new do |opts|
+        opts.on("--dryrun", "dry-run") do
+          @mode = DRYRUN_MODE
+        end
+        opts.on("--update", "Creates and deletes tasks as needed by schedule file") do
+          @mode = UPDATE_MODE
+        end
+        opts.on("-c", "--clear", "Clear scheduled tasks") do
+          @mode = CLEAR_MODE
+        end
+        opts.on("-l", "--list", "List scheduled tasks") do
+          @mode = LIST_MODE
+        end
+        opts.on("-v", "--version", "Print version") do
+          @mode = PRINT_VERSION_MODE
+        end
+        opts.on("-s", "--set variables", "Example: --set 'environment=staging'") do |set|
+          pairs = set.split("&")
+          pairs.each do |pair|
+            unless pair.include?("=")
+              Logger.instance.warn("Ignore variable set: #{pair}")
+              next
+            end
+            key, value = pair.split("=")
+            @variables << { key: key, value: value }
+          end
+        end
+        opts.on("--lambda-name name", "Lambda function name") do |name|
+          @lambda_name = name
+        end
+        opts.on("--scheduler-group group_name",
+                "Optionally specify event bridge scheduler group name") do |group|
+          @scheduler_group = group
+        end
+        opts.on("-f", "--file schedule_file", "Default: config/schedule.rb") do |file|
+          @schedule_file = file
+        end
+        opts.on("--iam-role name", "IAM role name used by EventBridgeScheduler.") do |role|
+          @iam_role = role
+        end
+        opts.on("--rule-state state", "The state of the EventBridgeScheduler Rule. Default: ENABLED") do |state|
+          @rule_state = state
+        end
+        opts.on("--region region", "AWS region") do |region|
+          @region = region
+        end
+        opts.on("-V", "--verbose", "Run rake jobs without --silent") do
+          @verbose = true
+        end
+      end.parse(args)
+    end
+
+    def validate!
+      raise InvalidOptionException, "Can't find file: #{schedule_file}" unless File.exist?(schedule_file)
+      raise InvalidOptionException, "You must set lambda-name" unless lambda_name
+      raise InvalidOptionException, "You must set iam-role" unless iam_role
+      return if POSSIBLE_RULE_STATES.include?(rule_state)
+
+      raise InvalidOptionException, "Invalid rule state. Possible values are #{POSSIBLE_RULE_STATES.join(", ")}"
+    end
+
+    def aws_config
+      @aws_config ||= { region: region }.delete_if { |_k, v| v.nil? }
+    end
+
+    def iam_client
+      @iam_client ||= Aws::IAM::Client.new(aws_config)
+    end
+
+    def lambda_client
+      @lambda_client ||= Aws::Lambda::Client.new(aws_config)
+    end
+
+    def scheduler_client
+      @scheduler_client ||= Aws::Scheduler::Client.new(aws_config)
+    end
+
+    def key
+      Digest::SHA1.hexdigest(
+        [
+          variables,
+          iam_role,
+          rule_state,
+          lambda_name,
+          scheduler_group
+        ].join
+      )
+    end
+
+    private
+
+    attr_reader :region
+  end
+end

data/lib/lambda_whenever/schedule.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative "whenever_numeric"
+
+module LambdaWhenever
+  class Schedule
+    attr_reader :tasks, :chronic_options, :bundle_command, :environment, :timezone
+
+    class UnsupportedFrequencyException < StandardError; end
+
+    using WheneverNumeric
+
+    def initialize(file, verbose, variables)
+      @environment = "production"
+      @verbose = verbose
+      @tasks = []
+      @chronic_options = {}
+      @bundle_command = "bundle exec"
+
+      variables.each { |var| set(var[:key], var[:value]) }
+      instance_eval(File.read(file), file)
+      @timezone ||= "UTC"
+    end
+
+    def set(key, value)
+      instance_variable_set("@#{key}", value) unless key == "tasks"
+    end
+
+    def every(frequency, options = {}, &block)
+      expressions = schedule_expressions(frequency, options)
+      tasks = expressions.map do |expression|
+        Task.new(@environment, @verbose, @bundle_command, expression).tap do |task|
+          task.instance_eval(&block)
+        end
+      end
+      @tasks.concat tasks
+    rescue UnsupportedFrequencyException => e
+      Logger.instance.warn(e.message)
+    end
+
+    def schedule_expressions(frequency, options)
+      tmp_expression = expression_by_frequency(frequency, options)
+      return ["cron(#{tmp_expression.join(" ")})"] unless options[:at].is_a?(Array)
+
+      times = options[:at]
+      grouped_times = times.group_by { |time| time[/\d\d?:(\d\d?)/, 1] }
+
+      grouped_times.map do |minute, hour_list|
+        hours = hour_list.map { |time| time[/^\d{1,2}/] }.join(",")
+        _, __, *rest = tmp_expression
+        exp = [minute, hours, *rest]
+        "cron(#{exp.join(" ")})"
+      end
+    end
+
+    # index minutes: 0, hours: 1, day_of_month: 2, month: 3, day_of_week: 4, year: 5
+    def expression_by_frequency(frequency, options)
+      opts = { now: Time.new(2017, 1, 1, 0, 0, 0) }.merge(@chronic_options)
+      time = Chronic.parse(options[:at], opts) || Time.new(2017, 1, 1, 0, 0, 0)
+
+      case frequency
+      when 1.minute
+        ["*", "*", "*", "*", "?", "*"]
+      when :hour, 1.hour
+        [time.min.to_s, "*", "*", "*", "?", "*"]
+      when :day, 1.day
+        [time.min.to_s, time.hour.to_s, "*", "*", "?", "*"]
+      when :month, 1.month
+        [time.min.to_s, time.hour.to_s, time.day, "*", "?", "*"]
+      when :year, 1.year
+        [time.min.to_s, time.hour.to_s, time.day, time.month, "?", "*"]
+      when :sunday
+        [time.min.to_s, time.hour.to_s, "?", "*", "SUN", "*"]
+      when :monday
+        [time.min.to_s, time.hour.to_s, "?", "*", "MON", "*"]
+      when :tuesday
+        [time.min.to_s, time.hour.to_s, "?", "*", "TUE", "*"]
+      when :wednesday
+        [time.min.to_s, time.hour.to_s, "?", "*", "WED", "*"]
+      when :thursday
+        [time.min.to_s, time.hour.to_s, "?", "*", "THU", "*"]
+      when :friday
+        [time.min.to_s, time.hour.to_s, "?", "*", "FRI", "*"]
+      when :saturday
+        [time.min.to_s, time.hour.to_s, "?", "*", "SAT", "*"]
+      when :weekend
+        [time.min.to_s, time.hour.to_s, "?", "*", "SUN,SAT", "*"]
+      when :weekday
+        [time.min.to_s, time.hour.to_s, "?", "*", "MON-FRI", "*"]
+      when 1.second...1.minute
+        raise UnsupportedFrequencyException, "Time must be in minutes or higher. Ignore this task."
+      when 1.minute...1.hour
+        step = (frequency / 60).round
+        min = []
+        ((60 % step).zero? ? 0 : step).step(59, step) { |i| min << i }
+        [min.join(","), "*", "*", "*", "?", "*"]
+      when 1.hour...1.day
+        step = (frequency / 60 / 60).round
+        hour = []
+        ((24 % step).zero? ? 0 : step).step(23, step) { |i| hour << i }
+        [time.min.to_s, hour.join(","), "*", "*", "?", "*"]
+      when 1.day...1.month
+        step = (frequency / 24 / 60 / 60).round
+        day = []
+        (step <= 16 ? 1 : step).step(30, step) { |i| day << i }
+        [time.min.to_s, time.hour.to_s, 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 }
+        [time.min.to_s, time.hour.to_s, time.day, month.join(","), "?", "*"]
+      when 12.months...Float::INFINITY
+        raise UnsupportedFrequencyException, "Time must be in months or lower. Ignore this task."
+      when %r{^((\*?[\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)/) { |match| Integer(match) + 1 }
+        year ||= "*"
+        [min, hour, day, mon, week, year]
+      when %r{^((\*?\??L?W?[\d/,-]*)\s*){6}$}
+        frequency.split(" ")
+      else
+        raise UnsupportedFrequencyException, "`#{frequency}` is not supported option. Ignore this task."
+      end
+    end
+
+    def print_tasks
+      @tasks.each do |task|
+        puts "#{task.expression} { commands: #{task.commands} }"
+      end
+    end
+
+    def method_missing(name, *_args)
+      Logger.instance.warn("Skipping unsupported method: #{name}")
+    end
+  end
+end

data/lib/lambda_whenever/target_lambda.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module LambdaWhenever
+  # The TargetLambda class represents a Lambda function as a target for scheduling.
+  class TargetLambda
+    attr_reader :role_arn, :arn, :input, :name, :task
+
+    class << self
+      def fetch_arn(function_name, client)
+        response = client.get_function({
+                                         function_name: function_name
+                                       })
+        response.configuration.function_arn
+      end
+    end
+
+    def initialize(arn:, task:)
+      @arn = arn
+      @task = task
+      @input = input_json
+    end
+
+    # https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-schedule-context-attributes.html
+    def input_json
+      {
+        execution_id: "<aws.scheduler.execution-id>",
+        scheduled_time: "<aws.scheduler.scheduled-time>",
+        schedule_arn: "<aws.scheduler.schedule-arn>",
+        attempt_number: "<aws.scheduler.attempt-number>",
+        commands: task.commands
+      }.to_json
+    end
+  end
+end

data/lib/lambda_whenever/task.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module LambdaWhenever
+  class Task
+    attr_reader :commands, :expression
+
+    def initialize(environment, verbose, bundle_command, expression)
+      @environment = environment
+      @verbose_mode = verbose ? nil : "--silent"
+      @bundle_command = bundle_command.split(" ")
+      @expression = expression
+      @commands = []
+    end
+
+    def command(task)
+      @commands << task.split(" ")
+    end
+
+    def rake(task)
+      @commands << [@bundle_command, "rake", task, @verbose_mode].flatten.compact
+    end
+
+    def runner(src)
+      @commands << [@bundle_command, "rails", "runner", "-e", @environment, src].flatten
+    end
+
+    def script(script)
+      @commands << [@bundle_command, "script/#{script}"].flatten
+    end
+
+    def method_missing(name, *_args)
+      Logger.instance.warn("Skipping unsupported method: #{name}")
+    end
+  end
+end

data/lib/lambda_whenever/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LambdaWhenever
+  VERSION = "0.1.0"
+end

data/lib/lambda_whenever/whenever_numeric.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module WheneverNumeric
+  refine Numeric do
+    def seconds
+      self
+    end
+    alias_method :second, :seconds
+
+    def minutes
+      self * 60
+    end
+    alias_method :minute, :minutes
+
+    def hours
+      (self * 60).minutes
+    end
+    alias_method :hour, :hours
+
+    def days
+      (self * 24).hours
+    end
+    alias_method :day, :days
+
+    def weeks
+      (self * 7).days
+    end
+    alias_method :week, :weeks
+
+    def months
+      (self * 30).days
+    end
+    alias_method :month, :months
+
+    def years
+      (self * 365.25).days
+    end
+    alias_method :year, :years
+  end
+end

data/lib/lambda_whenever.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "aws-sdk-iam"
+require "aws-sdk-scheduler"
+require "aws-sdk-lambda"
+require "chronic"
+require "singleton"
+require "json"
+require "retryable"
+
+require "lambda_whenever/version"
+require "lambda_whenever/cli"
+require "lambda_whenever/logger"
+require "lambda_whenever/option"
+require "lambda_whenever/schedule"
+require "lambda_whenever/event_bridge_scheduler"
+require "lambda_whenever/task"
+require "lambda_whenever/iam_role"
+require "lambda_whenever/target_lambda"
+
+module LambdaWhenever
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/lambda_whenever.rbs

@@ -0,0 +1,4 @@
+module LambdaWhenever
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,231 @@
+--- !ruby/object:Gem::Specification
+name: lambda_whenever
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- toshichanapp
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-09-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-iam
+  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: aws-sdk-lambda
+  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: aws-sdk-scheduler
+  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: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: chronic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: retryable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rexml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: whenever for Amazon EventBridge Scheduler.
+email:
+- toshichanapp@gmail.com
+executables:
+- lambda_whenever_dev
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- LICENSE
+- README.md
+- Rakefile
+- exe/lambda_whenever_dev
+- lib/lambda_whenever.rb
+- lib/lambda_whenever/cli.rb
+- lib/lambda_whenever/event_bridge_scheduler.rb
+- lib/lambda_whenever/iam_role.rb
+- lib/lambda_whenever/logger.rb
+- lib/lambda_whenever/option.rb
+- lib/lambda_whenever/schedule.rb
+- lib/lambda_whenever/target_lambda.rb
+- lib/lambda_whenever/task.rb
+- lib/lambda_whenever/version.rb
+- lib/lambda_whenever/whenever_numeric.rb
+- sig/lambda_whenever.rbs
+homepage: https://github.com/toshichanapp/lambda_whenever
+licenses: []
+metadata:
+  homepage_uri: https://github.com/toshichanapp/lambda_whenever
+  source_code_uri: https://github.com/toshichanapp/lambda_whenever
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key: 
+specification_version: 4
+summary: whenever for Amazon EventBridge Scheduler.
+test_files: []