rails-mongoid-scheduler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7400669410e9e4b5a7c85e4add4c6a6d0767f02ac4f52818e816c4dcc90391c8
+  data.tar.gz: de7abad7b8984bfbdb5512f69480eca81fc493d9c9b48582d1cab9e58eb31456
+SHA512:
+  metadata.gz: ff83ba06f6652263118cfe78c0d2f869ef1ae1e13dee21049872988a3464a0cf6fce7843bfae2801c069be0d4523c3fd518d4c95d618f62a729952b9a8b33f2a
+  data.tar.gz: b3a7de098fc62ba744e425a5c4224fa9e590b12fec074d43db440882b7edc917a628a02c731236ee98993eacfbc5fadc716fda60cbe68d750c96d7da90e907d3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 Francesco Ballardin
+
+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,48 @@
+# Scheduler
+This gem aims to create a simple yet efficient framework to handle job scheduling and execution. Currently it supports only MongoDB as database.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'scheduler'
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+And then install the config file with:
+```bash
+$ rails generate scheduler:config
+```
+
+## Usage
+This gem adds a `Scheduler` module which can be started, stopped or restarted with their corresponding rake task:
+```bash
+$ rails scheduler:start
+$ rails scheduler:stop
+$ rails scheduler:restart
+```
+A `Scheduler` is a process that keeps running looking for jobs to perform. The jobs are documents of a specific collection that you can specify in the scheduler configuration file. You can specify your own model to act as a schedulable entity, as long as it includes the `Schedulable` module. The other configuration options are explained in the generated `config/initializers/scheduler.rb` file.
+
+This gem also gives you a base ActiveJob implementation, called `SchedulerJob`, which you can subclass in order to implement your jobs.
+
+As an example, the gem comes with a `ExampleSchedulableModel` which is a bare class that just includes the `Schedulable` module, and also an `ExampleSchedulerJob` job which is a bare implementation of the `SchedulableJob` job that just sleeps for a given amount of time.
+
+First start by running the scheduler:
+```bash
+$ rails scheduler:start
+```
+
+You can then queue or run jobs by calling:
+```ruby
+ExampleSchedulableModel.perform_later('ExampleSchedulableJob', 10) # to queue
+ExampleSchedulableModel.perform_now('ExampleSchedulableJob', 10) # to perform immediately
+```
+Both methods create a document of `ExampleSchedulableModel` and put it in queue.
+The __perform_now__ method skips the scheduler and performs the job immediately, instead the __perform_later__ leaves the performing task to the scheduler.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,29 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Scheduler'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/jobs/example_scheduler_job.rb

@@ -0,0 +1,18 @@
+class ExampleSchedulerJob < SchedulerJob
+  
+  ##
+  # Performs job with ActiveJob framework.
+  #
+  # @param [String] job_id the id of the corresponding Job.
+  # @param [Integer] work_time an example amount of time to simulate work.
+  #
+  # @return [nil]
+  def perform(job_class, job_id, *args, &block)
+    super do |job, work_time|
+      job.log :info, "Preparing to do some work for #{work_time} seconds."
+      sleep work_time
+      job.log :info, "Work done!"
+    end
+  end
+
+end

data/app/jobs/scheduler_job.rb

@@ -0,0 +1,55 @@
+class SchedulerJob < ActiveJob::Base
+  
+  queue_as :default
+
+  ##
+  # Performs job with ActiveJob framework.
+  #
+  # @param [String] job_class the class of the corresponding Job.
+  # @param [String] job_id the id of the corresponding Job.
+  # @param [Array] *args additional arguments.
+  # @param [Proc] &block extra block to define custom jobs.
+  #
+  # @return [nil]
+  def perform(job_class, job_id, *args, &block)
+    begin
+      @job = job_class.constantize.find(job_id)
+      @job.executed_at = Time.current
+      @job.status!(:running)
+      yield @job, *args if block_given?
+      @job.completed_at = Time.current
+      @job.progress!(100)
+      @job.status!(:completed)
+    rescue StandardError => error
+      handle_error(error, job_class, job_id)
+    end
+  end
+
+  ##
+  # Method to handle any error raised when performing a job.
+  #
+  # @param [StandardError] error the raised error.
+  # @param [String] job_class the class of the corresponding Job.
+  # @param [String] job_id the id of the corresponding Job.
+  # @param [Proc] &block extra block to define custom error handling.
+  #
+  # @return [nil]
+  def handle_error(error, job_class, job_id, &block)
+    if @job.present?
+      @job.completed_at = Time.current
+      if block_given?
+        yield error
+      else
+        backtrace = error.backtrace.select { |line| line.include?('app') }.join("\n")
+        @job.log(:error, "#{error.class}: #{error.message}")
+        @job.log(:error, backtrace)
+        @job.backtrace = backtrace
+        @job.status!(:error)
+      end
+      @job.save
+    else
+      raise "Unable to find #{job_class} with id '#{job_id}'."
+    end
+  end
+
+end

data/app/models/example_schedulable_model.rb

@@ -0,0 +1,5 @@
+class ExampleSchedulableModel
+  
+  include Scheduler::Schedulable
+
+end

data/app/models/scheduler/schedulable.rb

@@ -0,0 +1,201 @@
+module Scheduler
+  module Schedulable
+
+    ##
+    # Possible schedulable statuses.
+    STATUSES = [ :queued, :running, :completed, :error, :locked ]
+
+    ##
+    # Possible log levels.
+    LOG_LEVELS = [ :debug, :info, :warn, :error ]
+
+    def self.included(base)
+
+      base.class_eval do
+        include Mongoid::Document
+
+        field :class_name,              type: String
+        field :args,                    type: Array,      default: []
+        field :scheduled_at,            type: DateTime
+        field :executed_at,             type: DateTime
+        field :completed_at,            type: DateTime
+        field :pid,                     type: Integer
+        field :status,                  type: Symbol,     default: :queued
+        field :logs,                    type: Array,      default: []
+        field :progress,                type: Float,      default: 0.0
+        field :error,                   type: String
+        field :backtrace,               type: String
+
+        scope :queued,      -> { where(status: :queued) }
+        scope :running,     -> { where(status: :running) }
+        scope :completed,   -> { where(status: :completed) }
+        scope :in_error,    -> { where(status: :error) }
+        scope :locked,      -> { where(status: :locked) }
+
+        validates_presence_of   :class_name
+
+        after_save              :broadcast
+
+        class << self
+        
+          ##
+          # Returns possible statuses.
+          #
+          # @return [Array<Symbol>] possible statuses.
+          def statuses
+            Scheduler::Schedulable::STATUSES
+          end
+
+          ##
+          # Returns possible log levels.
+          #
+          # @return [Array<Symbol>] possible log levels.
+          def log_levels
+            Scheduler::Schedulable::LOG_LEVELS
+          end
+
+          ##
+          # Returns the corresponding log color if this level.
+          #
+          # @param [Symbol] level log level.
+          #
+          # @return [Symbol] the color.
+          def log_color(level)
+            case level
+            when :debug then :green
+            when :info then :cyan
+            when :warn then :yellow
+            when :error then :red
+            end
+          end
+
+          ##
+          # Creates an instance of this class and calls :perform_later.
+          #
+          # @param [String] job_class the class of the job to run.
+          # @param [Array] *job_args job arguments
+          #
+          # @return [Object] the created job.
+          def perform_later(job_class, *job_args)
+            self.create(class_name: job_class, args: job_args).perform_later
+          end
+
+          ##
+          # Creates an instance of this class and calls :perform_now.
+          #
+          # @param [String] job_class the class of the job to run.
+          # @param [Array] *job_args job arguments
+          #
+          # @return [Object] the created job.
+          def perform_now(job_class, *job_args)
+            self.create(class_name: job_class, args: job_args).perform_now
+          end
+
+        end
+
+      end
+
+      ##
+      # Gets ActiveJob's job class.
+      #
+      # @return [Class] the ActiveJob's job class.
+      def job_class
+        self.class_name.constantize
+      end
+
+      ##
+      # Schedules the job.
+      #
+      # @return [Object] itself.
+      def schedule
+        self.scheduled_at = Time.current
+        self.status = :queued
+        self.logs = []
+        self.progress = 0.0
+        self.unset(:error)
+        self.unset(:backtrace)
+        self.unset(:completed_at)
+        self.unset(:executed_at)
+        self.save
+        if block_given?
+          yield self
+        else self end
+      end
+
+      ##
+      # Performs job when queue is available.
+      # On test or development env, the job is performed by ActiveJob queue,
+      # if configured on the Scheduler configuration.
+      # On production env, the job is performed only with a Scheduler::MainProcess.
+      #
+      # @return [Object] the job class.
+      def perform_later
+        self.schedule
+        if Rails.env.development? or Rails.env.test?
+          if Scheduler.configuration.perform_jobs_in_test_or_development
+            job_class.set(wait: 5.seconds).perform_later(self.class.name, self.id.to_s, *self.args)
+          end
+        end
+        self
+      end
+
+      ##
+      # Performs job when queue is available.
+      # On test or development env, the job is performed with ActiveJob.
+      # On production env, the job is performed with Scheduler.
+      #
+      # @return [Object] the job class.
+      def perform_now
+        self.schedule
+        job_class.perform_now(self.class.name, self.id.to_s, *self.args)
+        self
+      end
+
+      ##
+      # Immediately update the status to the given one.
+      #
+      # @param [Symbol] status the status to update.
+      #
+      # @return [nil]
+      def status!(status)
+        self.update(status: status)
+      end
+
+      ##
+      # Immediately increases progress to the given amount.
+      #
+      # @param [Float] amount the given progress amount.
+      def progress!(amount)
+        self.update(progress: amount.to_f) if amount.numeric?
+      end
+
+      ##
+      # Immediately increases progress by the given amount.
+      #
+      # @param [Float] amount the given progress amount.
+      def progress_by!(amount)
+        self.update(progress: progress + amount.to_f) if amount.numeric?
+      end
+
+      ##
+      # Registers a log message with the given level.
+      def log(level, message)
+        raise ArgumentError.new("The given log level '#{level}' is not valid. "\
+          "Valid log levels are: #{LOG_LEVELS.join(', ')}") unless level.in? LOG_LEVELS
+        Scheduler.configuration.logger.send level,
+          "[#{self.class}:#{self.id}] #{message}".send(self.class.log_color level)
+        self.update(logs: logs.push([level, message]))
+      end
+
+      ##
+      # Broadcasts a job updating event.
+      #
+      # @return [nil]
+      def broadcast
+        { status: status, logs: logs }
+      end
+
+    end
+
+  end
+end

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/lib/generators/scheduler/config_generator.rb

@@ -0,0 +1,18 @@
+require 'rails/generators'
+
+module Scheduler
+  module Generators
+    
+    class ConfigGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../templates", __FILE__)
+
+      desc "Creates a scheduler configuration file."
+
+      def copy_config
+        template "scheduler.rb", "config/initializers/scheduler.rb"
+      end
+
+    end
+
+  end
+end

data/lib/generators/templates/scheduler.rb

@@ -0,0 +1,42 @@
+##
+# Example configuration file for rails-scheduler gem.
+Scheduler.configure do |config|
+
+  ##
+  # A logger interface to save scheduler logs.
+  # Defaults to Rails.logger.
+  #
+  # config.logger = Rails.logger
+
+  ##
+  # A custom class to handle the execution of jobs.
+  # This class must include Scheduler::Schedulable module
+  # in order to work.
+  # Defaults to ExampleSchedulableModel, which is a bare class that
+  # just includes Scheduler::Schedulable module.
+  #
+  # config.job_class = ExampleSchedulableModel
+
+  ##
+  # How often the scheduler has to check for new jobs to run.
+  # Defaults to 5 seconds.
+  #
+  # config.polling_interval = 5
+  
+  ##
+  # How many jobs can run at a given time.
+  # Defaults to the minimum value between the number of the current
+  # machine CPU cores or 24.
+  #
+  # config.max_concurrent_jobs = [ Etc.nprocessors, 24 ].min
+
+  ##
+  # Sets whether to perform jobs when in test or development env.
+  # Usually jobs are performed only when a Scheduler::MainProcess is running.
+  # But for convenience, you can set this parameter to true so you
+  # don't need to keep a Scheduler::MainProcess running.
+  # Defaults to false.
+  #
+  # config.perform_jobs_in_test_or_development = false
+
+end

data/lib/scheduler.rb

@@ -0,0 +1,88 @@
+require "scheduler/engine"
+require "scheduler/configuration"
+require "scheduler/main_process"
+
+module Scheduler
+
+  class << self
+
+    # @return [Scheduler::Configuration] the configuration class for Scheduler.
+    attr_accessor :configuration
+
+    ##
+    # Initializes configuration.
+    #
+    # @return [Scheduler::Configuration] the configuration class for Scheduler.
+    def configuration
+      @configuration || Scheduler::Configuration.new
+    end
+
+    ##
+    # Method to configure various Scheduler options.
+    #
+    # @return [nil]
+    def configure
+      @configuration ||= Scheduler::Configuration.new
+      yield @configuration
+    end
+
+    ##
+    # Gets scheduler pid file.
+    #
+    # @return [String] the pid file.
+    def pid_file
+      '/tmp/rails-scheduler.pid'
+    end
+
+    ##
+    # Gets scheduler main process pid.
+    #
+    # @return [Integer] main process pid.
+    def pid
+      File.read(self.pid_file).to_i rescue nil
+    end
+
+    ##
+    # Starts a Scheduler::MainProcess in a separate process.
+    #
+    # @return [nil]
+    def start
+      scheduler_pid = Process.fork do
+        begin
+          Process.daemon(true)
+          File.open(self.pid_file, 'w+') do |pidfile|
+            pidfile.puts Process.pid
+          end
+          scheduler = Scheduler::MainProcess.new
+        rescue StandardError => e
+          Rails.logger.error "#{e.class}: #{e.message} (#{e.backtrace.first})".red
+        end
+      end
+      Process.detach(scheduler_pid)
+      scheduler_pid
+    end
+
+    ##
+    # Reschedules all running jobs and stops the scheduler main process.
+    #
+    # @return [nil]
+    def stop
+      begin  
+        Process.kill :TERM, Scheduler.pid
+        FileUtils.rm(self.pid_file)
+      rescue Errno::ENOENT, Errno::ESRCH
+      end
+    end
+
+    ##
+    # Restarts the scheduler.
+    #
+    # @return [nil]
+    def restart
+      self.stop
+      self.start
+    end
+
+  end
+
+end

data/lib/scheduler/configuration.rb

@@ -0,0 +1,24 @@
+module Scheduler
+  class Configuration
+
+    # @return [String] a logger file.
+    attr_accessor :logger
+    # @return [Class] the class of the main job model.
+    attr_accessor :job_class
+    # @return [Integer] how much time to wait before each iteration.
+    attr_accessor :polling_interval
+    # @return [Integer] maximum number of concurent jobs.
+    attr_accessor :max_concurrent_jobs
+    # @return [Boolean] whether to perform jobs when in test or development env.
+    attr_accessor :perform_jobs_in_test_or_development
+
+    def initialize
+      @logger = Rails.logger
+      @job_class = ExampleSchedulableModel
+      @polling_interval = 5
+      @max_concurrent_jobs = [ Etc.nprocessors, 24 ].min
+      @perform_jobs_in_test_or_development = false
+    end
+
+  end
+end

data/lib/scheduler/engine.rb

@@ -0,0 +1,8 @@
+module Scheduler
+  class Engine < ::Rails::Engine
+
+    # Loading required gems
+    require 'mongoid'
+
+  end
+end

data/lib/scheduler/main_process.rb

@@ -0,0 +1,136 @@
+module Scheduler
+  class MainProcess
+
+    # @return [Integer] pid of the main process.
+    attr_accessor :pid
+    # @return [String] a logger file.
+    attr_accessor :logger
+    # @return [Class] the class of the main job model.
+    attr_accessor :job_class
+    # @return [Integer] how much time to wait before each iteration.
+    attr_accessor :polling_interval
+    # @return [Integer] maximum number of concurent jobs.
+    attr_accessor :max_concurrent_jobs
+
+    ##
+    # Creates a MainProcess which keeps running
+    # and continuously checks if new jobs are queued.
+    #
+    # @return [Scheduler::MainProcess] the created MainProcess.
+    def initialize
+      @pid = Process.pid
+      @logger = Scheduler.configuration.logger
+      @job_class = Scheduler.configuration.job_class
+      @polling_interval = Scheduler.configuration.polling_interval
+      @max_concurrent_jobs = Scheduler.configuration.max_concurrent_jobs
+
+      unless @logger.instance_of?(ActiveSupport::Logger) or @logger.instance_of?(Logger)
+        @logger = Logger.new(@logger)
+      end
+
+      if @polling_interval < 1
+        @logger.warn "[Scheduler:#{@pid}] Warning: specified a polling interval lesser than 1: "\
+          "it will be forced to 1.".yellow
+        @polling_interval = 1
+      end
+      
+      unless @job_class.included_modules.include? Scheduler::Schedulable
+        raise "The given job class '#{@job_class}' is not a Schedulable class. "\
+          "Make sure to add 'include Scheduler::Schedulable' to your class."
+      end
+      
+      @logger.info "[Scheduler:#{@pid}] Starting scheduler..".cyan
+      self.start_loop
+    end
+  
+    ##
+    # Main loop.
+    #
+    # @return [nil]
+    def start_loop
+      loop do
+        begin
+          # Loads up a job queue.
+          queue = []
+          
+          # Counts jobs to schedule.
+          running_jobs = @job_class.running.entries
+          schedulable_jobs = @job_class.queued.order_by(scheduled_at: :asc).entries
+          jobs_to_schedule = @max_concurrent_jobs - running_jobs.count
+          jobs_to_schedule = 0 if jobs_to_schedule < 0
+  
+          # Finds out scheduled jobs waiting to be performed.
+          scheduled_jobs = []
+          schedulable_jobs.first(jobs_to_schedule).each do |job|
+            job_pid = Process.fork do
+              begin
+                job.perform_now
+              rescue StandardError => e
+                @logger.error "[Scheduler:#{@pid}] Error #{e.class}: #{e.message} "\
+                  "(#{e.backtrace.select { |l| l.include?('app') }.first}).".red
+              end
+            end
+            Process.detach(job_pid)
+            job.update_attribute(:pid, job_pid)
+            scheduled_jobs << job
+            queue << job.id.to_s
+          end
+  
+          # Logs launched jobs
+          if scheduled_jobs.any?
+            @logger.info "[Scheduler:#{@pid}] Launched #{scheduled_jobs.count} "\
+              "jobs: #{scheduled_jobs.map(&:id).map(&:to_s).join(', ')}.".cyan
+          else
+            if schedulable_jobs.count == 0
+              @logger.info "[Scheduler:#{@pid}] No jobs in queue.".cyan
+            else
+              @logger.warn "[Scheduler:#{@pid}] No jobs launched, reached maximum "\
+                "number of concurrent jobs. Jobs in queue: #{schedulable_jobs.count}.".yellow
+            end
+          end
+  
+          # Checks for completed jobs: clears up queue and kills any zombie pid
+          queue.delete_if do |job_id|
+            job = @job_class.find(job_id)
+            if job.present? and job.status.in? [ :completed, :error ]
+              begin
+                @logger.info "[Scheduler:#{@pid}] Rimosso processo #{job.pid} per lavoro completato".cyan
+                Process.kill :QUIT, job.pid
+              rescue Errno::ENOENT, Errno::ESRCH
+              end
+              true
+            else false end
+          end
+  
+          # Waits the specified amount of time before next iteration
+          sleep @polling_interval
+        rescue StandardError => error
+          @logger.error "[Scheduler:#{@pid}] Error #{error.message}".red
+          @logger.error error.backtrace.select { |line| line.include?('app') }.join("\n").red
+        rescue SignalException => signal
+          if signal.message.in? [ 'SIGINT', 'SIGTERM', 'SIGQUIT' ]
+            @logger.warn "[Scheduler:#{@pid}] Received interrupt, terminating scheduler..".yellow
+            reschedule_running_jobs
+            break
+          end
+        end
+      end
+    end
+
+    ##
+    # Reschedules currently running jobs.
+    #
+    # @return [nil]
+    def reschedule_running_jobs
+      @job_class.running.each do |job|
+        begin
+          Process.kill :QUIT, job.pid if job.pid.present?
+        rescue Errno::ESRCH, Errno::EPERM
+        ensure
+          job.schedule
+        end
+      end
+    end
+
+  end
+end

data/lib/scheduler/version.rb

@@ -0,0 +1,3 @@
+module Scheduler
+  VERSION = '0.1.0'
+end

data/lib/tasks/scheduler_tasks.rake

@@ -0,0 +1,18 @@
+namespace :scheduler do
+
+  desc 'Scheduler Start'
+  task :start => :environment do |t, args|
+     Scheduler.start
+  end
+  
+  desc 'Scheduler Stop'
+  task :stop => :environment do |t, args|
+     Scheduler.stop
+  end
+
+  desc 'Scheduler Restart'
+  task :restart => :environment do |t, args|
+     Scheduler.restart
+  end
+
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: rails-mongoid-scheduler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Francesco Ballardin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.2
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.2
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  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'
+- !ruby/object:Gem::Dependency
+  name: whenever
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: rails-dev-tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Rails engine to schedule jobs, handle parallel execution and manage
+  the jobs queue.
+email:
+- francesco.ballardin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/config/scheduler_manifest.js
+- app/jobs/example_scheduler_job.rb
+- app/jobs/scheduler_job.rb
+- app/models/example_schedulable_model.rb
+- app/models/scheduler/schedulable.rb
+- config/routes.rb
+- lib/generators/scheduler/config_generator.rb
+- lib/generators/templates/scheduler.rb
+- lib/scheduler.rb
+- lib/scheduler/configuration.rb
+- lib/scheduler/engine.rb
+- lib/scheduler/main_process.rb
+- lib/scheduler/version.rb
+- lib/tasks/scheduler_tasks.rake
+homepage: https://github.com/Pluvie/rails-scheduler
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A Rails engine to schedule jobs, handle parallel execution and manage the
+  jobs queue.
+test_files: []