pitchfork 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f23c677bd64eb8ca7a040cb2d41dab4047e05ae849da16af8e537748bfb6dbe
-  data.tar.gz: 890bac5b67c23d6f0aacf0d9130999cf69ac0bc5a2f1ea06bdd142d67c0606ac
+  metadata.gz: 3b4583ce30977e64c83d59160b7798f93073c6d0935d77c552e91397388bb434
+  data.tar.gz: 02c2c0abe2a400496c07bbe7f41c4d316eaed60b69a7681518a805b8e6f91a4a
 SHA512:
-  metadata.gz: 39c33bbbe865ba22bebc8b6b1e823f71d0ba6b2787f06af26f0ffe3d4251c781850826fcbcdf1dc13b1734919770e35dc57815d2de057f18d97ba354f247a3e7
-  data.tar.gz: 94e5ae39e129af1fd950c9a77e094bac5bda586f7358115fd8cf25bb3c6ee2079bb4654ebd4e6ed5e9ff498b461559da07d7b44acc0147fcac5c9a4695b7c62c
+  metadata.gz: 21360afc97d6172038ad4bfeae1c0fab4eeef787024c5a6743b0fb72fd61feb259666f0e9b0d519c9173072505f6f205d4bec2d764ec964173ea9116be20336f
+  data.tar.gz: b1faf79e0f186011c41523ff6bacc50a8ab1ad039fc0a9e934abc8fb17ffbbedcf9295fa50415f650b2a7ca30e019d3825079da1f83eaf10068c24c2b1734b08

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Unreleased
 
+# 0.11.0
+
+- Drop invalid response headers.
+- Enforce `spawn_timeout` for molds too.
+- Gracefully shutdown the server if the mold appear to be corrupted (#79).
+- Add more information in proctitle when forking a new sibbling.
+- Add a `before_fork` callback called before forking new molds and new workers.
+
 # 0.10.0
 
 - Include requests count in workers proctitle.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pitchfork (0.10.0)
+    pitchfork (0.11.0)
       rack (>= 2.0)
       raindrops (~> 0.7)
 

data/Rakefile

@@ -42,7 +42,6 @@ namespace :test do
   # preferable to edit the test suite as little as possible.
   task legacy_integration: :compile do
     File.write("test/integration/random_blob", File.read("/dev/random", 1_000_000))
-    lib = File.expand_path("lib", __dir__)
     path = "#{File.expand_path("exe", __dir__)}:#{ENV["PATH"]}"
     old_path = ENV["PATH"]
     ENV["PATH"] = "#{path}:#{old_path}"

data/docs/CONFIGURATION.md

@@ -241,10 +241,10 @@ for more details on nginx upstream configuration.
 ### `spawn_timeout`
 
 ```ruby
-timeout 5
+spawn_timeout 5
 ```
 
-Sets the timeout for a newly spawned worker to be ready after being spawned.
+Sets the timeout for a newly spawned worker or mold to be ready after being spawned.
 
 This timeout is a safeguard against various low-level fork safety bugs that could cause
 a process to dead-lock.
@@ -284,6 +284,16 @@ after_monitor_ready do |server|
 end
 ```
 
+### `before_fork`
+
+Called by the mold before forking a new workers, and by workers before they spawn a new mold.
+
+```ruby
+before_fork do |server|
+  server.logger.info("About to fork, closing connections!")
+end
+```
+
 ### `after_mold_fork`
 
 ```ruby
@@ -307,6 +317,11 @@ That is the case for instance of many SQL databases protocols.
 This is also the callback in which memory optimizations, such as
 heap compaction should be done.
 
+This callback is also a good place to check for potential corruption
+issues caused by forking. If you detect something wrong, you can
+call `Process.exit`, and this mold won't be used, another one will be
+spawned later. e.g. you can check `Socket.getaddrinfo` still works, etc.
+
 ### `after_worker_fork`
 
 ```ruby

data/docs/FORK_SAFETY.md

@@ -22,13 +22,17 @@ reopen connections and restart threads:
 ```ruby
 # pitchfork.conf.rb
 
-after_mold_fork do
+before_fork do
   Sequel::DATABASES.each(&:disconnect)
 end
 
-after_worker_fork do
+after_mold_fork do
   SomeLibary.connection.close
 end
+
+after_worker_fork do
+  SomeOtherLibary.connection.close
+end
 ```
 
 The documentation of any database client or network library you use should be

data/lib/pitchfork/children.rb

@@ -66,6 +66,11 @@ module Pitchfork
       @workers.key?(nr)
     end
 
+    def abandon(worker)
+      @workers.delete(worker.nr)
+      @pending_workers.delete(worker.nr)
+    end
+
     def reap(pid)
       if child = @children.delete(pid)
         @pending_workers.delete(child.nr)
@@ -73,6 +78,9 @@ module Pitchfork
         @molds.delete(child.pid)
         @workers.delete(child.nr)
         if @mold == child
+          @pending_workers.reject! do |nr, worker|
+            worker.generation == @mold.generation
+          end
           @mold = nil
         end
       end
@@ -99,6 +107,10 @@ module Pitchfork
       @molds.values
     end
 
+    def empty?
+      @children.empty?
+    end
+
     def each(&block)
       @children.each_value(&block)
     end
@@ -126,14 +138,6 @@ module Pitchfork
       end
     end
 
-    def hard_timeout(child)
-      child.hard_timeout!
-    rescue Errno::ESRCH
-      reap(child.pid)
-      child.close
-      true
-    end
-
     def workers
       @workers.values
     end

data/lib/pitchfork/configurator.rb

@@ -34,9 +34,11 @@ module Pitchfork
       :soft_timeout => 20,
       :cleanup_timeout => 2,
       :spawn_timeout => 10,
+      :timeout_signal => -> (_pid) { :KILL },
       :timeout => 22,
       :logger => default_logger,
       :worker_processes => 1,
+      :before_fork => nil,
       :after_worker_fork => lambda { |server, worker|
         server.logger.info("worker=#{worker.nr} gen=#{worker.generation} pid=#{$$} spawned")
       },
@@ -133,6 +135,10 @@ module Pitchfork
       set[:logger] = obj
     end
 
+    def before_fork(*args, &block)
+      set_hook(:before_fork, block_given? ? block : args[0], 1)
+    end
+
     def after_worker_fork(*args, &block)
       set_hook(:after_worker_fork, block_given? ? block : args[0])
     end
@@ -175,6 +181,19 @@ module Pitchfork
       set_int(:timeout, soft_timeout + cleanup_timeout, 5)
     end
 
+    def timeout_signal(*args, &block)
+      if block_given?
+        set_hook(:timeout_signal, block, 1)
+      elsif args.first.respond_to?(:call)
+        set_hook(:timeout_signal, args.first, 1)
+      elsif args.first.is_a?(Symbol)
+        signal = args.first
+        set_hook(:timeout_signal, ->(_pid) { signal }, 1)
+      else
+        raise ArgumentError, "timeout_signal must be a symbol or a proc"
+      end
+    end
+
     def spawn_timeout(seconds)
       set_int(:spawn_timeout, seconds, 1)
     end

data/lib/pitchfork/http_response.rb

@@ -14,6 +14,8 @@ module Pitchfork
     STATUS_CODES = defined?(Rack::Utils::HTTP_STATUS_CODES) ?
                    Rack::Utils::HTTP_STATUS_CODES : {}
 
+    ILLEGAL_HEADER_VALUE = /[\x00-\x08\x0A-\x1F]/
+
     # internal API, code will always be common-enough-for-even-old-Rack
     def err_response(code, response_start_sent)
       "#{response_start_sent ? '' : 'HTTP/1.1 '}" \
@@ -23,10 +25,16 @@ module Pitchfork
     def append_header(buf, key, value)
       case value
       when Array # Rack 3
-        value.each { |v| buf << "#{key}: #{v}\r\n" }
+        value.each do |v|
+          next if ILLEGAL_HEADER_VALUE.match?(v)
+          buf << "#{key}: #{v}\r\n"
+        end
       when /\n/ # Rack 2
         # avoiding blank, key-only cookies with /\n+/
-        value.split(/\n+/).each { |v| buf << "#{key}: #{v}\r\n" }
+        value.split(/\n+/).each do |v|
+          next if ILLEGAL_HEADER_VALUE.match?(v)
+          buf << "#{key}: #{v}\r\n"
+        end
       else
         buf << "#{key}: #{value}\r\n"
       end

data/lib/pitchfork/http_server.rb

@@ -74,8 +74,8 @@ module Pitchfork
     end
 
     # :stopdoc:
-    attr_accessor :app, :timeout, :soft_timeout, :cleanup_timeout, :spawn_timeout, :worker_processes,
-                  :after_worker_fork, :after_mold_fork,
+    attr_accessor :app, :timeout, :timeout_signal, :soft_timeout, :cleanup_timeout, :spawn_timeout, :worker_processes,
+                  :before_fork, :after_worker_fork, :after_mold_fork,
                   :listener_opts, :children,
                   :orig_app, :config, :ready_pipe,
                   :default_middleware, :early_hints
@@ -201,7 +201,7 @@ module Pitchfork
       else
         build_app!
         bind_listeners!
-        after_mold_fork.call(self, Worker.new(nil, pid: $$).promoted!)
+        after_mold_fork.call(self, Worker.new(nil, pid: $$).promoted!(@spawn_timeout))
       end
 
       if sync
@@ -315,7 +315,7 @@ module Pitchfork
         end
       end
       stop # gracefully shutdown all workers on our way out
-      logger.info "master complete"
+      logger.info "master complete status=#{@exit_status}"
       @exit_status
     end
 
@@ -368,7 +368,7 @@ module Pitchfork
       when Message::WorkerSpawned
         worker = @children.update(message)
         # TODO: should we send a message to the worker to acknowledge?
-        logger.info "worker=#{worker.nr} pid=#{worker.pid} registered"
+        logger.info "worker=#{worker.nr} pid=#{worker.pid} gen=#{worker.generation} registered"
       when Message::MoldSpawned
         new_mold = @children.update(message)
         logger.info("mold pid=#{new_mold.pid} gen=#{new_mold.generation} spawned")
@@ -394,7 +394,7 @@ module Pitchfork
       wait_for_pending_workers
       self.listeners = []
       limit = Pitchfork.time_now + timeout
-      until @children.workers.empty? || Pitchfork.time_now > limit
+      until @children.empty? || Pitchfork.time_now > limit
         if graceful
           @children.soft_kill_all(:TERM)
         else
@@ -404,11 +404,17 @@ module Pitchfork
           return StopIteration
         end
       end
-      @children.hard_kill_all(:KILL)
+
+      @children.each do |child|
+        if child.pid
+          @children.hard_kill(@timeout_signal.call(child.pid), child)
+        end
+      end
       @promotion_lock.unlink
     end
 
     def worker_exit(worker)
+      logger.info "worker=#{worker.nr} pid=#{worker.pid} gen=#{worker.generation} exiting"
       proc_name status: "exiting"
 
       if @before_worker_exit
@@ -494,8 +500,8 @@ module Pitchfork
       now = Pitchfork.time_now(true)
       next_sleep = @timeout - 1
 
-      @children.workers.each do |worker|
-        deadline = worker.deadline
+      @children.each do |child|
+        deadline = child.deadline
         if 0 == deadline # worker is idle
           next
         elsif deadline > now # worker still has time
@@ -506,28 +512,34 @@ module Pitchfork
           next
         else # worker is out of time
           next_sleep = 0
-          hard_timeout(worker)
+          hard_timeout(child)
         end
       end
 
       next_sleep <= 0 ? 1 : next_sleep
     end
 
-    def hard_timeout(worker)
-      if @after_worker_hard_timeout
+    def hard_timeout(child)
+      if child.pid.nil? # Not yet registered, likely never spawned
+        logger.error "worker=#{child.nr} timed out during spawn, abandoning"
+        @children.abandon(worker)
+        return
+      end
+
+      if @after_worker_hard_timeout && !child.mold?
         begin
-          @after_worker_hard_timeout.call(self, worker)
+          @after_worker_hard_timeout.call(self, child)
         rescue => error
           Pitchfork.log_error(@logger, "after_worker_hard_timeout callback", error)
         end
       end
 
-      if worker.mold?
-        logger.error "mold pid=#{worker.pid} timed out, killing"
+      if child.mold?
+        logger.error "mold pid=#{child.pid} gen=#{child.generation} timed out, killing"
       else
-        logger.error "worker=#{worker.nr} pid=#{worker.pid} timed out, killing"
+        logger.error "worker=#{child.nr} pid=#{child.pid} gen=#{child.generation} timed out, killing"
       end
-      @children.hard_timeout(worker) # take no prisoners for hard timeout violations
+      @children.hard_kill(@timeout_signal.call(child.pid), child) # take no prisoners for hard timeout violations
     end
 
     def trigger_refork
@@ -563,7 +575,8 @@ module Pitchfork
       # reason it gets stuck before reaching the worker loop,
       # the monitor process will kill it.
       worker.update_deadline(@spawn_timeout)
-      Pitchfork.fork_sibling do
+      @before_fork&.call(self)
+      fork_sibling("spawn_worker") do
         worker.pid = Process.pid
 
         after_fork_internal
@@ -598,6 +611,8 @@ module Pitchfork
         worker = Pitchfork::Worker.new(worker_nr)
 
         if REFORKING_AVAILABLE
+          worker.generation = @children.mold&.generation || 0
+
           unless @children.mold&.spawn_worker(worker)
             @logger.error("Failed to send a spawn_worker command")
           end
@@ -784,15 +799,18 @@ module Pitchfork
       readers << worker
       trap(:QUIT) { nuke_listeners!(readers) }
       trap(:TERM) { nuke_listeners!(readers) }
+      trap(:INT) { nuke_listeners!(readers); exit!(0) }
       readers
     end
 
     def init_mold_process(mold)
-      proc_name role: "(gen:#{mold.generation}) mold", status: "ready"
+      proc_name role: "(gen:#{mold.generation}) mold", status: "init"
       after_mold_fork.call(self, mold)
       readers = [mold]
       trap(:QUIT) { nuke_listeners!(readers) }
       trap(:TERM) { nuke_listeners!(readers) }
+      trap(:INT) { nuke_listeners!(readers); exit!(0) }
+      proc_name role: "(gen:#{mold.generation}) mold", status: "ready"
       readers
     end
 
@@ -831,7 +849,7 @@ module Pitchfork
               case client
               when Message::PromoteWorker
                 if Info.fork_safe?
-                  spawn_mold(worker.generation)
+                  spawn_mold(worker)
                 else
                   logger.error("worker=#{worker.nr} gen=#{worker.generation} is no longer fork safe, can't refork")
                 end
@@ -852,8 +870,8 @@ module Pitchfork
           if @refork_condition && Info.fork_safe? && !worker.outdated?
             if @refork_condition.met?(worker, logger)
               proc_name status: "requests: #{worker.requests_count}, spawning mold"
-              if spawn_mold(worker.generation)
-                logger.info("Refork condition met, promoting ourselves")
+              if spawn_mold(worker)
+                logger.info("worker=#{worker.nr} gen=#{worker.generation} Refork condition met, promoting ourselves")
               end
               @refork_condition.backoff!
             end
@@ -867,13 +885,17 @@ module Pitchfork
       end
     end
 
-    def spawn_mold(current_generation)
+    def spawn_mold(worker)
       return false unless @promotion_lock.try_lock
 
+      worker.update_deadline(@spawn_timeout)
+
+      @before_fork&.call(self)
+
       begin
-        Pitchfork.fork_sibling do
-          mold = Worker.new(nil, pid: Process.pid, generation: current_generation)
-          mold.promote!
+        fork_sibling("spawn_mold") do
+          mold = Worker.new(nil, pid: Process.pid, generation: worker.generation)
+          mold.promote!(@spawn_timeout)
           mold.start_promotion(@control_socket[1])
           mold_loop(mold)
         end
@@ -907,8 +929,18 @@ module Pitchfork
             when false
               # no message, keep looping
             when Message::SpawnWorker
+              retries = 1
               begin
                 spawn_worker(Worker.new(message.nr, generation: mold.generation), detach: true)
+              rescue ForkFailure
+                if retries > 0
+                  @logger.fatal("mold pid=#{mold.pid} gen=#{mold.generation} Failed to spawn a worker. Retrying.")
+                  retries -= 1
+                  retry
+                else
+                  @logger.fatal("mold pid=#{mold.pid} gen=#{mold.generation} Failed to spawn a worker twice in a row. Corrupted mold process?")
+                  Process.exit(1)
+                end
               rescue => error
                 raise BootFailure, error.message
               end
@@ -977,5 +1009,61 @@ module Pitchfork
       handler.timeout_request = SoftTimeout.request(@soft_timeout, handler)
       handler
     end
+
+    FORK_TIMEOUT = 5
+
+    def fork_sibling(role, &block)
+      if REFORKING_AVAILABLE
+        r, w = Pitchfork::Info.keep_ios(IO.pipe)
+        # We double fork so that the new worker is re-attached back
+        # to the master.
+        # This requires either PR_SET_CHILD_SUBREAPER which is exclusive to Linux 3.4
+        # or the master to be PID 1.
+        if middle_pid = FORK_LOCK.synchronize { Process.fork } # parent
+          w.close
+          # We need to wait(2) so that the middle process doesn't end up a zombie.
+          # The process only call fork again an exit so it should be pretty fast.
+          # However it might need to execute some `Process._fork` or `at_exit` callbacks,
+          # as well as Ruby's cleanup procedure to run finalizers etc, and there is a risk
+          # of deadlock.
+          # So in case it takes more than 5 seconds to exit, we kill it.
+          # TODO: rather than to busy loop here, we handle it in the worker/mold loop
+          process_wait_with_timeout(middle_pid, FORK_TIMEOUT)
+          pid_str = r.gets
+          r.close
+          if pid_str
+            Integer(pid_str)
+          else
+            raise ForkFailure, "fork_sibling didn't succeed in #{FORK_TIMEOUT} seconds"
+          end
+        else # first child
+          r.close
+          Process.setproctitle("<pitchfork fork_sibling(#{role})>")
+          pid = Pitchfork.clean_fork do
+            # detach into a grand child
+            w.close
+            yield
+          end
+          w.puts(pid)
+          w.close
+          exit
+        end
+      else
+        clean_fork(&block)
+      end
+    end
+
+    def process_wait_with_timeout(pid, timeout)
+      (timeout * 50).times do
+        _, status = Process.waitpid2(pid, Process::WNOHANG)
+        return status if status
+        sleep 0.02 # 50 * 20ms => 1s
+      end
+
+      # The process didn't exit in the allotted time, so we kill it.
+      Process.kill(@timeout_signal.call(pid), pid)
+      _, status = Process.waitpid2(pid)
+      status
+    end
   end
 end

data/lib/pitchfork/info.rb

@@ -26,7 +26,7 @@ module Pitchfork
         @map.each_key(&block)
       end
     end
-    
+
     @kept_ios = WeakSet.new
 
     class << self

data/lib/pitchfork/refork_condition.rb

@@ -2,6 +2,12 @@
 
 module Pitchfork
   module ReforkCondition
+    @backoff_delay = 10.0
+
+    class << self
+      attr_accessor :backoff_delay
+    end
+
     class RequestsCount
       def initialize(request_counts)
         @limits = request_counts
@@ -31,7 +37,7 @@ module Pitchfork
         end
       end
 
-      def backoff!(delay = 10.0)
+      def backoff!(delay = ReforkCondition.backoff_delay)
         @backoff_until = Pitchfork.time_now + delay
       end
     end

data/lib/pitchfork/shared_memory.rb

@@ -10,7 +10,8 @@ module Pitchfork
     CURRENT_GENERATION_OFFSET = 0
     SHUTDOWN_OFFSET = 1
     MOLD_TICK_OFFSET = 2
-    WORKER_TICK_OFFSET = 3
+    MOLD_PROMOTION_TICK_OFFSET = 3
+    WORKER_TICK_OFFSET = 4
 
     DROPS = [Raindrops.new(PER_DROP)]
 
@@ -49,6 +50,10 @@ module Pitchfork
       self[MOLD_TICK_OFFSET]
     end
 
+    def mold_promotion_deadline
+      self[MOLD_PROMOTION_TICK_OFFSET]
+    end
+
     def worker_deadline(worker_nr)
       self[WORKER_TICK_OFFSET + worker_nr]
     end

data/lib/pitchfork/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Pitchfork
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
   module Const
     UNICORN_VERSION = '6.1.0'
   end

data/lib/pitchfork/worker.rb

@@ -27,7 +27,7 @@ module Pitchfork
         @deadline_drop = SharedMemory.worker_deadline(nr)
         self.deadline = 0
       else
-        promoted!
+        promoted!(nil)
       end
     end
 
@@ -55,6 +55,13 @@ module Pitchfork
       message.class.members.each do |member|
         send("#{member}=", message.public_send(member))
       end
+
+      case message
+      when Message::MoldSpawned
+        @deadline_drop = SharedMemory.mold_promotion_deadline
+      when Message::MoldReady
+        @deadline_drop = SharedMemory.mold_deadline
+      end
     end
 
     def register_to_master(control_socket)
@@ -75,6 +82,7 @@ module Pitchfork
       message = Message::MoldReady.new(@nr, @pid, generation)
       control_socket.sendmsg(message)
       SharedMemory.current_generation = @generation
+      @deadline_drop = SharedMemory.mold_deadline
     end
 
     def promote(generation)
@@ -85,16 +93,16 @@ module Pitchfork
       send_message_nonblock(Message::SpawnWorker.new(new_worker.nr))
     end
 
-    def promote!
+    def promote!(timeout)
       @generation += 1
-      promoted!
+      promoted!(timeout)
     end
 
-    def promoted!
+    def promoted!(timeout)
       @mold = true
       @nr = nil
-      @deadline_drop = SharedMemory.mold_deadline
-      self.deadline = 0
+      @deadline_drop = SharedMemory.mold_promotion_deadline
+      update_deadline(timeout) if timeout
       self
     end
 
@@ -143,10 +151,6 @@ module Pitchfork
       Process.kill(sig, pid)
     end
 
-    def hard_timeout!
-      hard_kill(:KILL)
-    end
-
     # this only runs when the Rack app.call is not running
     # act like a listener
     def accept_nonblock(exception: nil) # :nodoc:

data/lib/pitchfork.rb

@@ -33,6 +33,7 @@ module Pitchfork
   ClientShutdown = Class.new(EOFError)
 
   BootFailure = Class.new(StandardError)
+  ForkFailure = Class.new(StandardError)
 
   # :stopdoc:
 
@@ -196,43 +197,6 @@ module Pitchfork
       end
     end
 
-    def fork_sibling(&block)
-      if REFORKING_AVAILABLE
-        # We double fork so that the new worker is re-attached back
-        # to the master.
-        # This requires either PR_SET_CHILD_SUBREAPER which is exclusive to Linux 3.4
-        # or the master to be PID 1.
-        if middle_pid = FORK_LOCK.synchronize { Process.fork } # parent
-          # We need to wait(2) so that the middle process doesn't end up a zombie.
-          # The process only call fork again an exit so it should be pretty fast.
-          # However it might need to execute some `Process._fork` or `at_exit` callbacks,
-          # so it case it takes more than 5 seconds to exit, we kill it with SIGBUS
-          # to produce a crash report, as this is indicative of a nasty bug.
-          process_wait_with_timeout(middle_pid, 5, :BUS)
-        else # first child
-          Process.setproctitle("<pitchfork fork_sibling>")
-          clean_fork(&block) # detach into a grand child
-          exit
-        end
-      else
-        clean_fork(&block)
-      end
-
-      nil # it's tricky to return the PID
-    end
-
-    def process_wait_with_timeout(pid, timeout, timeout_signal = :KILL)
-      (timeout * 200).times do
-        status = Process.wait(pid, Process::WNOHANG)
-        return status if status
-        sleep 0.005 # 200 * 5ms => 1s
-      end
-
-      # The process didn't exit in the allotted time, so we kill it.
-      Process.kill(timeout_signal, pid)
-      Process.wait(pid)
-    end
-
     def time_now(int = false)
       Process.clock_gettime(Process::CLOCK_MONOTONIC, int ? :second : :float_second)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pitchfork
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Jean Boussier
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-02 00:00:00.000000000 Z
+date: 2023-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: raindrops