mongodb-scheduler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1f5897d6a1c9c893e29684eeda0caf7df9483e5be15189394fd8ed0d38364e9d
+  data.tar.gz: 882ed7f055f70e508384ae99290c89b9192d6ba8970b8fd78dfb152148aec256
+SHA512:
+  metadata.gz: cb04a2d1a3b86b7fddfaf18216a74b41e1616461fd8a823140126b9a8e8d7345951318b4413632d0789f60dbca06d5122ce22835f6b38d838f7f2e25666ce4fb
+  data.tar.gz: 51b1fc7b25deb36af0ca733dc836a719b641e8d1418242ee2fcb49dba23550bc9294b65491787534227b13c817e8bd5ada33c2b316718db7efde092b86e97e16

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/log/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.3
+before_install: gem install bundler -v 2.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in scheduler.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,73 @@
+PATH
+  remote: .
+  specs:
+    scheduler (0.1.0)
+      bson_ext
+      hanami-cli
+      hanami-mongoid
+      logger
+      mongoid
+      rainbow
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (5.2.3)
+      activesupport (= 5.2.3)
+    activesupport (5.2.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    bson (4.4.2)
+    bson_ext (1.5.1)
+    concurrent-ruby (1.1.5)
+    diff-lcs (1.3)
+    hanami-cli (0.3.1)
+      concurrent-ruby (~> 1.0)
+      hanami-utils (~> 1.3)
+    hanami-mongoid (0.1.7)
+      mongoid
+    hanami-utils (1.3.1)
+      concurrent-ruby (~> 1.0)
+      transproc (~> 1.0)
+    i18n (1.6.0)
+      concurrent-ruby (~> 1.0)
+    logger (1.3.0)
+    minitest (5.11.3)
+    mongo (2.8.0)
+      bson (>= 4.4.2, < 5.0.0)
+    mongoid (7.0.2)
+      activemodel (>= 5.1, < 6.0.0)
+      mongo (>= 2.5.1, < 3.0.0)
+    rainbow (3.0.0)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    thread_safe (0.3.6)
+    transproc (1.0.3)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  scheduler!
+
+BUNDLED WITH
+   2.0.1

data/README.md

@@ -0,0 +1,46 @@
+# Scheduler
+This gem aims to create a simple yet efficient framework to handle job scheduling and execution. It is targeted for MongoDB database.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mongodb-scheduler'
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+## Usage
+This gem adds a `Scheduler` module which can be started, stopped or restarted with their corresponding command:
+```bash
+$ scheduler start
+$ scheduler stop
+$ 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 template file `lib/scheduler/templates/scheduler.rb` file.
+
+As an example, the gem comes with a `Scheduler::Examples::SchedulableModel` which is a bare class that just includes the `Scheduler::Schedulable` module, and also an `Scheduler::Examples::ExecutableClass` class which is a bare implementation of an executable class.
+An executable class is just a plain Ruby class which must implement a `call` method which accepts one argument. This argument is an instance of the schedulable model that you configured.
+
+First start by running the scheduler:
+```bash
+$ scheduler start
+```
+
+You can then queue jobs by calling:
+```ruby
+YourSchedulableModel.schedule('YourExecutableClass', args...) # to queue
+```
+Both methods create a document of `YourSchedulableModel` 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.
+
+If you want to stop the scheduler, just run:
+```bash
+$ scheduler stop
+```
+
+## 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,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "scheduler"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/scheduler

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "scheduler"
+Scheduler::CLI.new.call

data/lib/scheduler/cli.rb

@@ -0,0 +1,33 @@
+require "hanami/cli"
+
+module Scheduler
+  class CLI
+    def call(*args)
+      Hanami::CLI.new(Commands).call(*args)
+    end
+
+    module Commands
+      extend Hanami::CLI::Registry
+
+      class Start < Hanami::CLI::Command
+        def call(*)
+          Scheduler.start
+        end
+      end
+      class Stop < Hanami::CLI::Command
+        def call(*)
+          Scheduler.stop
+        end
+      end
+      class Restart < Hanami::CLI::Command
+        def call(*)
+          Scheduler.restart
+        end
+      end
+
+      register "start", Start
+      register "stop", Stop
+      register "restart", Restart
+    end
+  end
+end

data/lib/scheduler/configuration.rb

@@ -0,0 +1,30 @@
+module Scheduler
+  class Configuration
+
+    # @return [String] envinronment of your app
+    attr_accessor :environment
+    # @return [String] a path to Mongoid config file.
+    attr_accessor :mongoid_config_file
+    # @return [String] a path to the specified log file.
+    attr_accessor :log_file
+    # @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 [Proc] whether to perform jobs when in test or development env.
+    attr_accessor :perform_jobs_in_test_or_development
+
+    def initialize
+      @environment = 'test'
+      @mongoid_config_file = File.join(Scheduler.root, 'spec/mongoid.yml')
+      @log_file = STDOUT
+      @job_class = Scheduler::Examples::SchedulableModel
+      @polling_interval = 5
+      @max_concurrent_jobs = [ Etc.nprocessors, 24 ].min
+      @perform_jobs_in_test_or_development = false
+    end
+
+  end
+end

data/lib/scheduler/examples/executable_class.rb

@@ -0,0 +1,13 @@
+module Scheduler
+  module Examples
+    class ExecutableClass
+
+      def initialize(*args)
+      end
+
+      def call(job)
+        job.log :info, 'Example of execution.'
+      end
+    end
+  end
+end

data/lib/scheduler/examples/schedulable_model.rb

@@ -0,0 +1,9 @@
+require_relative '../schedulable'
+
+module Scheduler
+  module Examples
+    class SchedulableModel
+      include Scheduler::Schedulable
+    end
+  end
+end

data/lib/scheduler/main_process.rb

@@ -0,0 +1,134 @@
+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
+      @logger = Scheduler.logger
+      @pid = Process.pid
+      @job_class = Scheduler.configuration.job_class
+      @polling_interval = Scheduler.configuration.polling_interval
+      @max_concurrent_jobs = Scheduler.configuration.max_concurrent_jobs
+
+      if @polling_interval < 1
+        logger.warn Rainbow("[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
+
+      # Loads up a job queue.
+      @queue = []
+
+      @logger.info Rainbow("[Scheduler:#{@pid}] Starting main loop..").cyan
+      self.start_loop
+    end
+  
+    ##
+    # Main loop.
+    #
+    # @return [nil]
+    def start_loop
+      loop do
+        begin          
+          # 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(Process.pid)
+              rescue StandardError => e
+                @logger.error Rainbow("[Scheduler:#{@pid}] Error #{e.class}: #{e.message}.").red
+                @logger.error Rainbow(e.backtrace.join("\n")).red
+              end
+            end
+            Process.detach(job_pid)
+            scheduled_jobs << job
+            @queue << job.id.to_s
+          end
+  
+          # Logs launched jobs
+          if scheduled_jobs.any?
+            @logger.info Rainbow("[Scheduler:#{@pid}] Launched #{scheduled_jobs.count} "\
+              "jobs: #{scheduled_jobs.map(&:id).map(&:to_s).join(', ')}.").cyan
+          else
+            if schedulable_jobs.count == 0
+              @logger.info Rainbow("[Scheduler:#{@pid}] No jobs in queue.").cyan
+            else
+              @logger.warn Rainbow("[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?
+              unless job.status.in? [ :queued, :running ]
+                begin
+                  @logger.info Rainbow("[Scheduler:#{@pid}] Removed process #{job.pid}, job is completed.").cyan
+                  Process.kill :QUIT, job.pid
+                rescue Errno::ENOENT, Errno::ESRCH
+                end
+                return true
+              end
+            end
+            false
+          end
+  
+          # Waits the specified amount of time before next iteration
+          sleep @polling_interval
+        rescue StandardError => error
+          @logger.error Rainbow("[Scheduler:#{@pid}] Error #{e.class}: #{error.message}").red
+          @logger.error Rainbow(error.backtrace.join("\n")).red
+        rescue SignalException => signal
+          if signal.message.in? [ 'SIGINT', 'SIGTERM', 'SIGQUIT' ]
+            @logger.warn Rainbow("[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/schedulable.rb

@@ -0,0 +1,181 @@
+module Scheduler
+  module Schedulable
+
+    ##
+    # Possible schedulable statuses.
+    STATUSES = [ :queued, :running, :completed, :warning, :error, :locked ]
+
+    ##
+    # Possible log levels.
+    LOG_LEVELS = [ :debug, :info, :warn, :error ]
+
+    def self.included(base)
+      base.class_eval do
+        include Mongoid::Document
+
+        field :executable_class,        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 :to_check,    -> { where(status: :warning) }
+        scope :in_error,    -> { where(status: :error) }
+        scope :locked,      -> { where(status: :locked) }
+
+        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 schedules the job.
+          #
+          # @param [String] executable_class the class of the job to run.
+          # @param [Array] *job_args job arguments
+          #
+          # @return [Object] the created job.
+          def schedule(executable_class, *job_args)
+            self.create(executable_class: executable_class, args: job_args).schedule
+          end
+
+          ##
+          # Creates an instance of this class and performs the job.
+          #
+          # @param [String] executable_class the class of the job to run.
+          # @param [Array] *job_args job arguments
+          #
+          # @return [Object] the created job.
+          def perform(executable_class, *job_args)
+            self.create(executable_class: executable_class, args: job_args).perform
+          end
+
+        end
+
+        ##
+        # Gets executor job class.
+        #
+        # @return [Class] the executor job class.
+        def executable_class
+          Object.const_get self[:executable_class]
+        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
+          if Scheduler.perform_jobs_in_test_or_development?
+            self.perform
+          end
+        end
+
+        ##
+        # Performs the job.
+        #
+        # @param [Integer] pid the executing pid.
+        #
+        # @return [Object] the instanced executable_class.
+        def perform(pid = nil)
+          job = self.executable_class.new(*self.args)
+          raise Scheduler::Error.new "#{self.executable_class} does not implement method 'call'. Please make "\
+            "sure to implement it before performing the job." unless job.respond_to? :call
+          self.status!(:running)
+          self.update(pid: pid) if pid.present?
+          job.call(self)
+          self.completed_at = Time.current
+          if self.status == :running
+            self.progress!(100)
+            self.status!(:completed)
+          end
+          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 Scheduler::Error.new "The given log level '#{level}' is not valid. "\
+            "Valid log levels are: #{LOG_LEVELS.join(', ')}" unless level.in? LOG_LEVELS
+          Scheduler.logger.send level, Rainbow("[#{self.class}:#{self.id}] #{message}").send(self.class.log_color level)
+          self.update(logs: logs.push([level, message]))
+        end
+      end
+    end
+
+  end
+end

data/lib/scheduler/templates/scheduler.rb

@@ -0,0 +1,54 @@
+##
+# Example configuration file for rails-scheduler gem.
+Scheduler.configure do |config|
+
+  ##
+  # Current running environment.
+  # Defaults to 'test'.
+  #
+  # config.environment = 'test'
+
+  ##
+  # A path to Mongoid config file.
+  # Defaults to Scheduler gem test Mongoid config.
+  #
+  # config.mongoid_config_file = File.join(Scheduler.root, "spec/mongoid.yml")
+
+  ##
+  # A path to a specific log file.
+  # Defaults to STDOUT.
+  #
+  # config.log_file = STDOUT
+
+  ##
+  # 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/version.rb

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

data/lib/scheduler.rb

@@ -0,0 +1,131 @@
+require "rainbow"
+require "logger"
+require "mongoid"
+require_relative "scheduler/version"
+require_relative "scheduler/schedulable"
+require_relative "scheduler/examples/schedulable_model"
+require_relative "scheduler/examples/executable_class"
+require_relative "scheduler/cli"
+require_relative "scheduler/configuration"
+require_relative "scheduler/main_process"
+
+module Scheduler
+  class Error < StandardError; end
+
+  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
+
+    ##
+    # Returns Scheduler gem root path.
+    #
+    # @return [String] Scheduler gem root path.
+    def root
+      File.dirname __dir__
+    end
+
+    ##
+    # Returns current environment.
+    #
+    # @return [String] Scheduler environment.
+    def env
+      Scheduler.configuration.environment
+    end
+
+    ##
+    # Gets scheduler pid file.
+    #
+    # @return [String] the pid file.
+    def pid_file
+      '/tmp/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
+
+    ##
+    # Checks whether to run jobs in test or development.
+    #
+    # @return [Boolean] to run jobs.
+    def perform_jobs_in_test_or_development?
+      Scheduler.configuration.perform_jobs_in_test_or_development
+    end
+
+    ##
+    # Return the Scheduler logger.
+    #
+    # @return [Logger] the configured logger.
+    def logger
+      @@logger ||= Logger.new Scheduler.configuration.log_file
+    end
+
+    ##
+    # Starts a Scheduler::MainProcess in a separate process.
+    #
+    # @return [nil]
+    def start
+      logger.info Rainbow("[Scheduler:#{Process.pid}] Starting..").cyan
+      scheduler_pid = Process.fork do
+        begin
+          logger.info Rainbow("[Scheduler:#{Process.pid}] Forked.").cyan
+          Process.daemon(true)
+          logger.info Rainbow("[Scheduler:#{Process.pid}] Going into background..").cyan
+          File.open(self.pid_file, 'w+') do |pidfile|
+            pidfile.puts Process.pid
+          end
+          scheduler = Scheduler::MainProcess.new
+        rescue StandardError => e
+          puts Rainbow("#{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 TypeError, Errno::ENOENT, Errno::ESRCH
+      end
+    end
+
+    ##
+    # Restarts the scheduler.
+    #
+    # @return [nil]
+    def restart
+      self.stop
+      self.start
+    end
+
+  end
+
+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

data/scheduler.gemspec

@@ -0,0 +1,35 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "scheduler/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mongodb-scheduler"
+  spec.version       = Scheduler::VERSION
+  spec.authors       = ["Francesco Ballardin"]
+  spec.email         = ["francesco.ballardin@develonproject.com"]
+
+  spec.summary       = %q{A gem to schedule jobs, handle parallel execution and manage the jobs queue.}
+  spec.description   = %q{A gem to schedule jobs, handle parallel execution and manage the jobs queue.}
+  spec.homepage      = "https://github.com/Pluvie/mongodb-scheduler"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "mongoid"
+  spec.add_dependency "bson_ext"
+  spec.add_dependency "rainbow"
+  spec.add_dependency "hanami-cli"
+  spec.add_dependency "hanami-mongoid"
+  spec.add_dependency "logger"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification
+name: mongodb-scheduler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Francesco Ballardin
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-04-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  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: 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: rainbow
+  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: hanami-cli
+  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: hanami-mongoid
+  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: logger
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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'
+description: A gem to schedule jobs, handle parallel execution and manage the jobs
+  queue.
+email:
+- francesco.ballardin@develonproject.com
+executables:
+- scheduler
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/scheduler
+- lib/scheduler.rb
+- lib/scheduler/cli.rb
+- lib/scheduler/configuration.rb
+- lib/scheduler/examples/executable_class.rb
+- lib/scheduler/examples/schedulable_model.rb
+- lib/scheduler/main_process.rb
+- lib/scheduler/schedulable.rb
+- lib/scheduler/templates/scheduler.rb
+- lib/scheduler/version.rb
+- lib/tasks/scheduler_tasks.rake
+- scheduler.gemspec
+homepage: https://github.com/Pluvie/mongodb-scheduler
+licenses: []
+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 gem to schedule jobs, handle parallel execution and manage the jobs queue.
+test_files: []