lambda_whenever 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67a5c5474ef6496852336282c2a377f9f6c0063d0ab366c0af32ccaf2913c379
-  data.tar.gz: f823d4e7f110f729553ea01187c712d6adb0b3a85b1edbb97218fd95b64f1cd6
+  metadata.gz: 5f129b23aca4d25d6b995c09a9d1644a6d8f510f2a620996168ca2eff79a292d
+  data.tar.gz: ec91d0520bb573d4f630bfe8b07fc7fbe4a15b41930ea6aaeb146046c4ae24e9
 SHA512:
-  metadata.gz: 14ecdce83d2156801ddd4af596ba084dbd5a1741b97f74c39bd64d541df34573a070c56fd18dc628678069551c0f8d0befeea4721ec3110fee3cb4c23d370212
-  data.tar.gz: 1239df92546e75453eb7ead19baf439515451e80ae538a11f9b926648bc74b146af06d70f75afc2ed1f520bfa57ea76a3bfb53a603a1267afb548ae3a2cf9c1d
+  metadata.gz: 900fd11c932e0620aea048f497be0b59655e45422953794fa13fc0ae149ad0662d9832de3283ede985ffec566ec8eacc74c01c2f20991621cdd5f1f7a75933f1
+  data.tar.gz: df722523f0dca951232658b021f4ad81cf9d320fabd0fedcc866a04a407a59c69210df9ac4431ba01d8d9451251dcc44c879ba2f921924961714ed6deb78074d

data/lib/lambda_whenever/cli.rb

@@ -26,6 +26,12 @@ module LambdaWhenever
           update_eb_schedules
         end
         Logger.instance.log("write", "scheduled tasks updated")
+      when Option::SYNC_MODE
+        option.validate!
+        with_concurrent_modification_handling do
+          sync_eb_schedules
+        end
+        Logger.instance.log("write", "scheduled tasks updated")
       when Option::CLEAR_MODE
         with_concurrent_modification_handling do
           clear_tasks
@@ -68,6 +74,26 @@ module LambdaWhenever
       end
     end
 
+    def sync_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)
+
+      current_schedules = scheduler.list_schedules(option.scheduler_group)
+      lambda_arn = TargetLambda.fetch_arn(option.lambda_name, option.lambda_client)
+      desired_schedules = schedule.tasks.map do |task|
+        target = TargetLambda.new(arn: lambda_arn, task: task)
+        {
+          name: scheduler.schedule_name(task, option),
+          target: target,
+          task: task
+        }
+      end
+
+      scheduler.sync_schedules(desired_schedules, current_schedules, option)
+    end
+
     def clear_tasks
       scheduler = EventBridgeScheduler.new(option.scheduler_client)
       scheduler.clean_up_schedules(option.scheduler_group)

data/lib/lambda_whenever/event_bridge_scheduler.rb

@@ -13,17 +13,60 @@ module LambdaWhenever
     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|
+      response.schedules.map do |schedule|
         detail = @scheduler_client.get_schedule({ group_name: group_name, name: schedule.name })
-        puts "#{schedule.state} #{schedule.name} #{detail.schedule_expression} #{detail.description}"
+        Logger.instance.message "#{schedule.state} #{schedule.name} #{detail.schedule_expression} #{detail.description}"
+        {
+          name: schedule.name,
+          state: schedule.state,
+          expression: detail.schedule_expression,
+          description: detail.description
+        }
+      end
+    end
+
+    def sync_schedules(desired_schedules, current_schedules, option)
+      desired_names = desired_schedules.map { |s| s[:name] }.to_set
+      current_schedules_hash = current_schedules.to_h do |schedule|
+        [schedule[:name], schedule]
+      end
+      current_names = current_schedules_hash.keys.to_set
+      to_delete = current_names - desired_names
+
+      to_add, to_update = desired_schedules.each_with_object([[], []]) do |desired, (add, update)|
+        current = current_schedules_hash[desired[:name]]
+        if current.nil?
+          add << desired
+        elsif schedules_differ?(current, desired, option)
+          update << desired
+        end
+      end
+
+      Logger.instance.message("Deleting #{to_delete.length} schedules...")
+      to_delete.each do |name|
+        Logger.instance.message "delete schedule: #{name}"
+        delete_schedule(name, option.scheduler_group)
+      end
+
+      Logger.instance.message("Creating #{to_add.length} schedules...")
+      to_add.each do |schedule|
+        Logger.instance.message "create schedule: #{schedule[:name]}"
+        create_schedule(schedule[:target], option)
+      end
+
+      Logger.instance.message("Updating #{to_update.length} schedules...")
+      to_update.each do |desired|
+        Logger.instance.message("Updating schedule: #{desired[:name]}")
+        delete_schedule(desired[:name], option.scheduler_group)
+        create_schedule(desired[:target], option)
       end
     end
 
     def create_schedule_group(group_name)
       @scheduler_client.create_schedule_group({ name: group_name })
-      puts "Schedule group '#{group_name}' created."
+      Logger.instance.message "Schedule group '#{group_name}' created."
     rescue Aws::Scheduler::Errors::ConflictException
-      puts "Schedule group '#{group_name}' already exists."
+      Logger.instance.message "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
@@ -49,7 +92,8 @@ module LambdaWhenever
     end
 
     def schedule_name(task, option)
-      Digest::SHA1.hexdigest([option.key, task.expression, *task.commands].join("-")).to_s[0, 64]
+      input = "#{task.name}-#{Digest::SHA1.hexdigest([option.key, task.expression, *task.commands].join("-"))}"
+      sanitize_and_trim(input)
     end
 
     def schedule_description(task)
@@ -59,13 +103,31 @@ module LambdaWhenever
     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
-                                          })
+        delete_schedule(schedule.name, schedule_group)
       end
+    end
+
+    private
+
+    def sanitize_and_trim(input)
+      sanitized = input.gsub(/[^a-zA-Z0-9\-._]/, "_")
+      sanitized[0, 64]
+    end
+
+    def schedules_differ?(current, desired, option)
+      task = desired[:target].task
+      current[:expression] != task.expression ||
+        current[:description] != schedule_description(task) ||
+        current[:state] != option.rule_state
+    end
+
+    def delete_schedule(name, group_name)
+      @scheduler_client.delete_schedule({
+                                          name: name,
+                                          group_name: group_name
+                                        })
     rescue Aws::Scheduler::Errors::ResourceNotFoundException
-      puts "Schedule group '#{schedule_group}' does not exist."
+      Logger.instance.message("Schedule '#{name}' does not exist.")
     end
   end
 end

data/lib/lambda_whenever/option.rb

@@ -10,6 +10,7 @@ module LambdaWhenever
     CLEAR_MODE = 3
     LIST_MODE = 4
     PRINT_VERSION_MODE = 5
+    SYNC_MODE = 6
 
     attr_reader :mode, :verbose, :variables, :schedule_file, :iam_role, :rule_state,
                 :lambda_name, :scheduler_group
@@ -31,9 +32,12 @@ module LambdaWhenever
         opts.on("--dryrun", "dry-run") do
           @mode = DRYRUN_MODE
         end
-        opts.on("--update", "Creates and deletes tasks as needed by schedule file") do
+        opts.on("--update", "clear and create schedules") do
           @mode = UPDATE_MODE
         end
+        opts.on("--sync", "Creates and deletes tasks as needed by schedule file") do
+          @mode = SYNC_MODE
+        end
         opts.on("-c", "--clear", "Clear scheduled tasks") do
           @mode = CLEAR_MODE
         end

data/lib/lambda_whenever/task.rb

@@ -2,7 +2,7 @@
 
 module LambdaWhenever
   class Task
-    attr_reader :commands, :expression
+    attr_reader :commands, :expression, :name
 
     def initialize(environment, verbose, bundle_command, expression)
       @environment = environment
@@ -10,6 +10,7 @@ module LambdaWhenever
       @bundle_command = bundle_command.split(" ")
       @expression = expression
       @commands = []
+      @name = ""
     end
 
     def command(task)
@@ -17,14 +18,17 @@ module LambdaWhenever
     end
 
     def rake(task)
-      @commands << [@bundle_command, "rake", task, @verbose_mode].flatten.compact
+      @name = task
+      @commands << [*@bundle_command, "rake", task, *@verbose_mode]
     end
 
     def runner(src)
+      @name = src
       @commands << [@bundle_command, "rails", "runner", "-e", @environment, src].flatten
     end
 
     def script(script)
+      @name = script
       @commands << [@bundle_command, "script/#{script}"].flatten
     end
 

data/lib/lambda_whenever/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lambda_whenever
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - toshichanapp
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-09-03 00:00:00.000000000 Z
+date: 2024-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -224,7 +224,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.22
 signing_key: 
 specification_version: 4
 summary: whenever for Amazon EventBridge Scheduler.