crono_trigger 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f8410e0b2dd3dc398df839baba03aaec050d3e31
+  data.tar.gz: 945ece057b38511d03324505c4fe960420b9f581
+SHA512:
+  metadata.gz: 76e9b4270e9d9ea439106e88e5e031a2489212f4caaf8dedd0e39c0ba3d64189b0a3c7ecc6e67d9dfbdaffcfcfb27cbe8839a4860268c00fcede1f8c5a4f5fd5
+  data.tar.gz: 5adc3071703de67b4d9a894b32e4ede1677dcc119fdb8fdc021fdae4f232e56d297984363eaf5d4d1eec586226841666bef9ffa6d2713e166ff524fc4c583a74

data/.gitignore

@@ -0,0 +1,20 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/gemfiles/.bundle
+*.gemfile.lock
+
+# rspec failure tracking
+.rspec_status
+
+log/*.log
+spec/dummy/db/*.sqlite3
+spec/dummy/db/*.sqlite3-journal
+spec/dummy/log/*.log
+spec/dummy/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,10 @@
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.4.1
+  - 2.3.3
+gemfile:
+  - gemfiles/activerecord-42.gemfile
+  - gemfiles/activerecord-50.gemfile
+  - gemfiles/activerecord-51.gemfile

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 joker1007
+
+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,146 @@
+# CronoTrigger
+
+Asynchronous Job Scheduler for Rails.
+
+The purpose of this gem is to integrate job schedule into Service Domain.
+
+Because of it, this gem uses ActiveRecord model as definition of job schedule.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'crono_trigger'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install crono_trigger
+
+## Usage
+
+#### Execute `crono_trigger:model` generator.
+
+```
+$ rails g crono_trigger:model mail_notification
+      create  db/migrate/20170619064928_create_mail_notifications.rb
+      create  app/models/mail_notification.rb
+      # ...
+```
+
+#### Migration sample
+
+```ruby
+class CreateMailNotifications < ActiveRecord::Migration
+  def change
+    create_table :mail_notifications do |t|
+
+      # columns for CronoTrigger::Schedulable
+      t.string    :cron
+      t.datetime  :next_execute_at
+      t.datetime  :last_executed_at
+      t.integer   :execute_lock, limit: 8, default: 0, null: false
+      t.datetime  :started_at, null: false
+      t.datetime  :finished_at
+      t.string    :last_error_name
+      t.string    :last_error_reason
+      t.datetime  :last_error_time
+      t.integer   :retry_count, default: 0, null: false
+
+
+      t.timestamps
+    end
+    add_index :mail_notifications, [:next_execute_at, :execute_lock, :started_at, :finished_at], name: "crono_trigger_index_on_mail_notifications"
+  end
+end
+```
+
+#### Implement `#execute` method
+
+```ruby
+class MailNotification < ActiveRecord::Base
+  include CronoTrigger::Schedulable
+
+  self.crono_trigger_options = {
+    retry_limit: 5,
+    retry_interval: 10,
+    exponential_backoff: true,
+    execute_lock_timeout: 300,
+  }
+
+  # `execute` callback is defined
+  # can use `before_execute`, `after_execute`, `around_execute`
+
+  # If execute method raise Exception, worker retry task until reach `retry_limit`
+  # If `retry_count` reaches `retry_limit`, task schedule is reset.
+  # 
+  # If record has cron value, reset process set next execution time by cron definition
+  # If record has no cron value, reset process clear next execution time
+  def execute
+    send_mail
+
+    throw :retry # break execution and retry task
+    throw :abort # break execution and raise AbortExecution. AbortExecution is not retried
+    throw :ok    # break execution and handle task as success
+  end
+end
+```
+
+#### Run Worker
+
+```
+$ crono_trigger MailNotification
+```
+
+```
+$ crono_trigger --help
+Usage: crono_trigger [options] MODEL [MODEL..]
+    -f, --config-file=CONFIG         Config file (ex. ./crono_trigger.rb)
+    -e, --envornment=ENV             Set environment name (ex. development, production)
+    -p, --polling-thread=SIZE        Polling thread size (Default: 1)
+    -i, --polling-interval=SECOND    Polling interval seconds (Default: 5)
+    -c, --concurrency=SIZE           Execute thread size (Default: 25)
+    -l, --log=LOGFILE                Set log output destination (Default: STDOUT or ./crono_trigger.log if daemonize is true)
+        --log-level=LEVEL            Set log level (Default: info)
+    -d, --daemonize                  Daemon mode
+        --pid=PIDFILE                Set pid file
+    -h, --help                       Prints this help
+```
+
+## Specification
+
+### Columns
+
+|name             |type    |required|description                                                                                                                                                  |
+|-----------------|--------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|cron             |string  |no      |Recurring schedule formatted by cron style                                                                                                                   |
+|next_execute_at  |datetime|yes     |Timestamp of next execution. Worker executes task if this column <= now                                                                                      |
+|last_executed_at |datetime|no      |Timestamp of last execution                                                                                                                                  |
+|execute_lock     |integer |yes     |Timestamp of fetching record in order to hide record from other transaction during execute lock timeout. <br> when execution complete this column is reset to 0|
+|started_at       |datetime|no      |Timestamp of schedule activated                                                                                                                              |
+|finished_at      |datetime|no      |Timestamp of schedule deactivated                                                                                                                            |
+|last_error_name  |string  |no      |Class name of last error                                                                                                                                     |
+|last_error_reason|string  |no      |Error message of last error                                                                                                                                  |
+|last_error_time  |datetime|no      |Timestamp of last error occured                                                                                                                              |
+|retry_count      |integer |no      |Retry count. <br> If execution succeed retry_count is reset to 0                                                                                                  |
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/joker1007/crono_trigger.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,47 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+pwd = File.expand_path('../', __FILE__)
+
+gemfiles = Dir.glob(File.join(pwd, "gemfiles", "*.gemfile")).map { |f| File.basename(f, ".*") }
+
+namespace :spec do
+  gemfiles.each do |gemfile|
+    desc "Run Tests by #{gemfile}.gemfile"
+    task gemfile do
+      Bundler.with_clean_env do
+        sh "BUNDLE_GEMFILE='#{pwd}/gemfiles/#{gemfile}.gemfile' bundle install --path #{pwd}/.bundle"
+        sh "BUNDLE_GEMFILE='#{pwd}/gemfiles/#{gemfile}.gemfile' bundle exec rake -t spec"
+      end
+    end
+  end
+
+  desc "Run All Tests"
+  task :all do
+    gemfiles.each do |gemfile|
+      Rake::Task["spec:#{gemfile}"].invoke
+    end
+  end
+end
+
+namespace :bundle_update do
+  gemfiles.each do |gemfile|
+    desc "Run Tests by #{gemfile}.gemfile"
+    task gemfile do
+      Bundler.with_clean_env do
+        sh "BUNDLE_GEMFILE='#{pwd}/gemfiles/#{gemfile}.gemfile' bundle update"
+      end
+    end
+  end
+
+  desc "Run All Tests"
+  task :all do
+    gemfiles.each do |gemfile|
+      Rake::Task["bundle_update:#{gemfile}"].invoke
+    end
+  end
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "crono_trigger"
+
+# 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/crono_trigger.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'crono_trigger/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "crono_trigger"
+  spec.version       = CronoTrigger::VERSION
+  spec.authors       = ["joker1007"]
+  spec.email         = ["kakyoin.hierophant@gmail.com"]
+
+  spec.summary       = %q{In Service Asynchronous Job Scheduler for Rails}
+  spec.description   = %q{In Service Asynchronous Job Scheduler for Rails. This gem handles ActiveRecord model as schedule definition.}
+  spec.homepage      = "https://github.com/joker1007/crono_trigger"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |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 "chrono"
+  spec.add_dependency "serverengine"
+  spec.add_dependency "concurrent-ruby"
+  spec.add_dependency "activerecord", ">= 4.2"
+
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "database_rewinder"
+  spec.add_development_dependency "timecop"
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/exe/crono_trigger

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require "crono_trigger/cli"

data/gemfiles/activerecord-42.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.2.0"
+
+gemspec :path => "../"

data/gemfiles/activerecord-50.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "activerecord", "~> 5.0.0"
+
+gemspec :path => "../"

data/gemfiles/activerecord-51.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "activerecord", "~> 5.1.0"
+
+gemspec :path => "../"

data/lib/crono_trigger.rb

@@ -0,0 +1,36 @@
+require "crono_trigger/version"
+
+require "ostruct"
+require "active_record"
+require "concurrent"
+require "crono_trigger/worker"
+require "crono_trigger/polling_thread"
+require "crono_trigger/schedulable"
+
+module CronoTrigger
+  @config = OpenStruct.new(
+    polling_thread: 1,
+    polling_interval: 5,
+    executor_thread: 25,
+    model_names: [],
+  )
+
+  def self.config
+    @config
+  end
+
+  def self.configure
+    yield config
+  end
+
+  def self.load_config(yml, environment = nil)
+    config = YAML.load_file(yml)[environment || "default"]
+    config.each do |k, v|
+      @config[k] = v
+    end
+  end
+end
+
+if defined?(Rails)
+  require "crono_trigger/railtie"
+end

data/lib/crono_trigger/cli.rb

@@ -0,0 +1,80 @@
+require "optparse"
+require "crono_trigger"
+require "serverengine"
+
+options = {
+  daemonize: false,
+  pid_path: "./crono_trigger.pid",
+}
+
+opt_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: crono_trigger [options] MODEL [MODEL..]"
+
+  opts.on("-f", "--config-file=CONFIG", "Config file (ex. ./crono_trigger.rb)") do |cfg|
+    options[:config] = cfg
+  end
+
+  opts.on("-e", "--envornment=ENV", "Set environment name (ex. development, production)") do |env|
+    options[:env] = env
+  end
+
+  opts.on("-p", "--polling-thread=SIZE", Integer, "Polling thread size (Default: 1)") do |i|
+    options[:polling_thread] = i
+  end
+
+  opts.on("-i", "--polling-interval=SECOND", Integer, "Polling interval seconds (Default: 5)") do |i|
+    options[:polling_interval] = i
+  end
+
+  opts.on("-c", "--concurrency=SIZE", Integer, "Execute thread size (Default: 25)") do |i|
+    options[:execute_thread] = i
+  end
+
+  opts.on("-l", "--log=LOGFILE", "Set log output destination (Default: STDOUT or ./crono_trigger.log if daemonize is true)") do |log|
+    options[:log] = log
+  end
+
+  opts.on("--log-level=LEVEL", "Set log level (Default: info)") do |log_level|
+    options[:log_level] = log_level
+  end
+
+  opts.on("-d", "--daemonize", "Daemon mode") do
+    options[:daemonize] = true
+  end
+
+  opts.on("--pid=PIDFILE", "Set pid file") do |pid|
+    options[:pid_path] = pid
+  end
+
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+end
+
+opt_parser.parse!
+
+begin
+  require "rails"
+  require File.expand_path("./config/environment", Rails.root)
+rescue LoadError
+end
+
+CronoTrigger.load_config(options[:config], options[:env]) if options[:config]
+
+%i(polling_thread polling_interval execute_thread).each do |name|
+  CronoTrigger.config[name] = options[name] if options[name]
+end
+
+CronoTrigger.config.model_names.concat(ARGV)
+
+se = ServerEngine.create(nil, CronoTrigger::Worker, {
+  daemonize: options[:daemonize],
+  log: options[:log] || (options[:daemonize] ? "./crono_trigger.log" : "-"),
+  log_level: options[:log_level] || "info",
+  pid_path: options[:pid_path] || (options[:daemonize] ? "./crono_trigger.pid" : nil),
+  supervisor: true,
+  server_process_name: "crono_trigger[worker]",
+  restart_server_process: true,
+})
+se.run

data/lib/crono_trigger/polling_thread.rb

@@ -0,0 +1,60 @@
+module CronoTrigger
+  class PollingThread
+    def initialize(model_queue, stop_flag, logger, executor)
+      @model_queue = model_queue
+      @stop_flag = stop_flag
+      @logger = logger
+      @executor = executor
+    end
+
+    def run
+      @thread = Thread.start do
+        @logger.info "(polling-thread-#{Thread.current.object_id}) Start polling thread"
+        until @stop_flag.wait_for_set(CronoTrigger.config.polling_interval)
+          begin
+            model = @model_queue.pop(true)
+            poll(model)
+          rescue ThreadError => e
+            logger.error(e) unless e.message == "queue empty"
+          rescue => e
+            logger.error(e)
+          ensure
+            @model_queue << model if model
+          end
+        end
+      end
+    end
+
+    def join
+      @thread.join
+    end
+
+    def poll(model)
+      @logger.debug "(polling-thread-#{Thread.current.object_id}) Poll #{model}"
+      records = []
+      primary_key_offset = nil
+      begin
+        begin
+          conn = model.connection_pool.checkout
+          records = model.executables_with_lock(primary_key_offset: primary_key_offset)
+          primary_key_offset = records.last && records.last.id
+        ensure
+          model.connection_pool.checkin(conn)
+        end
+
+        records.each do |record|
+          @executor.post do
+            model.connection_pool.with_connection do
+              @logger.info "(executor-thread-#{Thread.current.object_id}) Execute #{record.class}-#{record.id}"
+              begin
+                record.do_execute
+              rescue Exception => e
+                @logger.error(e)
+              end
+            end
+          end
+        end
+      end while records.any?
+    end
+  end
+end

data/lib/crono_trigger/railtie.rb

@@ -0,0 +1,4 @@
+module CronoTrigger
+  class Railtie < ::Rails::Railtie
+  end
+end

data/lib/crono_trigger/schedulable.rb

@@ -0,0 +1,158 @@
+require "active_support/concern"
+require "chrono"
+
+module CronoTrigger
+  module Schedulable
+    DEFAULT_RETRY_LIMIT = 10
+    DEFAULT_RETRY_INTERVAL = 4
+    DEFAULT_EXECUTE_LOCK_TIMEOUT = 600
+
+    class AbortExecution < StandardError; end
+
+    extend ActiveSupport::Concern
+    include ActiveSupport::Callbacks
+
+    included do
+      class_attribute :crono_trigger_options
+      self.crono_trigger_options = {}
+
+      define_model_callbacks :execute
+
+      scope :executables, ->(from: Time.current, primary_key_offset: nil, limit: 1000) do
+        t = arel_table
+
+        rel = where(t[:next_execute_at].lteq(from))
+          .where(t[:execute_lock].lteq(from.to_i - (crono_trigger_options[:execute_lock_timeout] || DEFAULT_EXECUTE_LOCK_TIMEOUT)))
+
+        rel = rel.where(t[:started_at].lteq(from)) if column_names.include?("started_at")
+        rel = rel.where(t[:finished_at].gt(from).or(t[:finished_at].eq(nil)))  if column_names.include?("finished_at")
+        rel = rel.where(t[primary_key].gt(primary_key_offset)) if primary_key_offset
+
+        rel = rel.order("#{quoted_table_name}.#{quoted_primary_key} ASC").limit(limit)
+
+        rel
+      end
+
+      before_create :ensure_next_execute_at
+    end
+
+    module ClassMethods
+      def executables_with_lock(primary_key_offset: nil, limit: 1000)
+        records = nil
+        transaction do
+          records = executables(primary_key_offset: primary_key_offset, limit: limit).lock.to_a
+          unless records.empty?
+            where(id: records).update_all(execute_lock: Time.current.to_i)
+          end
+          records
+        end
+      end
+    end
+
+    def do_execute
+      run_callbacks :execute do
+        catch(:ok) do
+          catch(:retry) do
+            catch(:abort) do
+              execute
+              throw :ok
+            end
+            raise AbortExecution
+          end
+          retry!
+          return
+        end
+        reset!(true)
+      end
+    rescue AbortExecution => ex
+      save_last_error_info(ex)
+      reset!
+
+      raise
+    rescue Exception => ex
+      save_last_error_info(ex)
+      retry_or_reset!
+
+      raise
+    end
+
+    def retry!
+      logger.info "Retry #{self.class}-#{id}" if logger
+
+      now = Time.current
+      wait = crono_trigger_options[:exponential_backoff] ? retry_interval * [2 * (retry_count - 1), 1].max : retry_interval
+      attributes = {next_execute_at: now + wait, execute_lock: 0}
+
+      if self.class.column_names.include?("retry_count")
+        attributes.merge!(retry_count: retry_count.to_i + 1)
+      end
+
+      update_columns(attributes)
+    end
+
+    def reset!(update_last_executed_at = false)
+      logger.info "Reset execution schedule #{self.class}-#{id}" if logger
+
+      attributes = {next_execute_at: calculate_next_execute_at, execute_lock: 0}
+
+      if update_last_executed_at && self.class.column_names.include?("last_executed_at")
+        attributes.merge!(last_executed_at: Time.current)
+      end
+
+      if self.class.column_names.include?("retry_count")
+        attributes.merge!(retry_count: 0)
+      end
+
+      update_columns(attributes)
+    end
+
+    private
+
+    def retry_or_reset!
+      if respond_to?(:retry_count) && retry_count.to_i <= retry_limit
+        retry!
+      else
+        reset!
+      end
+    end
+
+    def calculate_next_execute_at
+      if respond_to?(:cron) && cron
+        it = Chrono::Iterator.new(cron)
+        it.next
+      end
+    end
+
+    def ensure_next_execute_at
+      self.next_execute_at ||= calculate_next_execute_at || Time.current
+    end
+
+    def retry_limit
+      crono_trigger_options[:retry_limit] || DEFAULT_RETRY_LIMIT
+    end
+
+    def retry_interval
+      crono_trigger_options[:retry_interval] || DEFAULT_RETRY_INTERVAL
+    end
+
+    def save_last_error_info(ex)
+      columns = self.class.column_names
+      attributes = {}
+      now = Time.current
+
+      if columns.include?("last_error_name")
+        attributes.merge!(last_error_name: ex.class.to_s)
+      end
+
+      if columns.include?("last_error_reason")
+        attributes.merge!(last_error_reason: ex.message)
+      end
+
+      if columns.include?("last_error_time")
+        attributes.merge!(last_error_time: now)
+      end
+
+      update_columns(attributes)
+    end
+  end
+end

data/lib/crono_trigger/version.rb

@@ -0,0 +1,3 @@
+module CronoTrigger
+  VERSION = "0.0.1"
+end

data/lib/crono_trigger/worker.rb

@@ -0,0 +1,32 @@
+require "active_support/core_ext/string"
+
+module CronoTrigger
+  module Worker
+    def initialize
+      @stop_flag = ServerEngine::BlockingFlag.new
+      @model_queue = Queue.new
+      CronoTrigger.config.model_names.each do |model_name|
+        model = model_name.classify.constantize
+        @model_queue << model
+      end
+      @executor = Concurrent::ThreadPoolExecutor.new(
+        min_threads: 1,
+        max_threads: CronoTrigger.config.executor_thread,
+      )
+      ActiveRecord::Base.logger = logger
+    end
+
+    def run
+      polling_threads = CronoTrigger.config.polling_thread.times.map { PollingThread.new(@model_queue, @stop_flag, logger, @executor) }
+      polling_threads.each(&:run)
+      polling_threads.each(&:join)
+
+      @executor.shutdown
+      @executor.wait_for_termination
+    end
+
+    def stop
+      @stop_flag.set!
+    end
+  end
+end

data/lib/generators/crono_trigger/migration/migration_generator.rb

@@ -0,0 +1,11 @@
+require "rails/generators/active_record/migration/migration_generator"
+
+module CronoTrigger
+  module Generators
+    class MigrationGenerator < ActiveRecord::Generators::MigrationGenerator
+      source_root File.expand_path("../templates", __FILE__)
+
+      desc "Create migration for Scheduled Job"
+    end
+  end
+end

data/lib/generators/crono_trigger/migration/templates/create_table_migration.rb

@@ -0,0 +1,38 @@
+class <%= migration_class_name %> < ActiveRecord::Migration<%= Rails::VERSION::MAJOR >= 5 ? "[#{ActiveRecord::Migration.current_version}]" : "" %>
+  def change
+    create_table :<%= table_name %><%= respond_to?(:primary_key_type) ? primary_key_type : "" %> do |t|
+<% attributes.each do |attribute| -%>
+<% if attribute.password_digest? -%>
+      t.string :password_digest<%= attribute.inject_options %>
+<% elsif attribute.respond_to?(:token?) && attribute.token? -%>
+      t.string :<%= attribute.name %><%= attribute.inject_options %>
+<% else -%>
+      t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
+<% end -%>
+<% end -%>
+
+      # columns for CronoTrigger::Schedulable
+      t.string    :cron
+      t.datetime  :next_execute_at
+      t.datetime  :last_executed_at
+      t.integer   :execute_lock, limit: 8, default: 0, null: false
+      t.datetime  :started_at, null: false
+      t.datetime  :finished_at
+      t.string    :last_error_name
+      t.string    :last_error_reason
+      t.datetime  :last_error_time
+      t.integer   :retry_count, default: 0, null: false
+
+<% if options[:timestamps] %>
+      t.timestamps<%= Rails::VERSION::MAJOR >=5 ? " null: false" : "" %>
+<% end -%>
+    end
+    <% attributes.select { |attribute| attribute.respond_to?(:token?) && attribute.token? }.each do |attribute| -%>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>, unique: true
+<% end -%>
+<% attributes_with_index.each do |attribute| -%>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
+<% end -%>
+    add_index :<%= table_name %>, [:next_execute_at, :execute_lock, :started_at, :finished_at], name: "crono_trigger_index_on_<%= table_name %>"
+  end
+end

data/lib/generators/crono_trigger/migration/templates/migration.rb

@@ -0,0 +1,15 @@
+class <%= migration_class_name %> < ActiveRecord::Migration<%= Rails::VERSION::MAJOR >= 5 ? "[#{ActiveRecord::Migration.current_version}]" : "" %>
+  def change
+    # columns for CronoTrigger::Schedulable
+    add_column :<%= table_name %>, :cron, :string
+    add_column :<%= table_name %>, :next_execute_at, :datetime
+    add_column :<%= table_name %>, :last_executed_at, :datetime
+    add_column :<%= table_name %>, :execute_lock, :integer, limit: 8, default: 0, null: false
+    add_column :<%= table_name %>, :started_at, :datetime, null: false
+    add_column :<%= table_name %>, :finished_at, :datetime
+    add_column :<%= table_name %>, :last_error_name, :string
+    add_column :<%= table_name %>, :last_error_reason, :string
+    add_column :<%= table_name %>, :last_error_time, :string
+    add_column :<%= table_name %>, :retry_count, :integer, default: 0, null: false
+  end
+end

data/lib/generators/crono_trigger/model/model_generator.rb

@@ -0,0 +1,11 @@
+require "rails/generators/active_record/model/model_generator"
+
+module CronoTrigger
+  module Generators
+    class ModelGenerator < ActiveRecord::Generators::ModelGenerator
+      source_root File.expand_path("../templates", __FILE__)
+
+      desc "Create model for Scheduled Job"
+    end
+  end
+end

data/lib/generators/crono_trigger/model/templates/model.rb

@@ -0,0 +1,17 @@
+<% module_namespacing do -%>
+class <%= class_name %> < <%= parent_class_name.classify %>
+<% attributes.select(&:reference?).each do |attribute| -%>
+  belongs_to :<%= attribute.name %><%= ', polymorphic: true' if attribute.polymorphic? %><%= ', required: true' if attribute.required? %>
+<% end -%>
+<% attributes.select { |attribute| attribute.respond_to?(:token?) && attribute.token? }.each do |attribute| -%>
+  has_secure_token<% if attribute.name != "token" %> :<%= attribute.name %><% end %>
+<% end -%>
+<% if attributes.any?(&:password_digest?) -%>
+  has_secure_password
+<% end -%>
+
+  def execute
+    # Implement this
+  end
+end
+<% end -%>

metadata

@@ -0,0 +1,212 @@
+--- !ruby/object:Gem::Specification
+name: crono_trigger
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- joker1007
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-06-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chrono
+  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: serverengine
+  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: concurrent-ruby
+  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: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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'
+- !ruby/object:Gem::Dependency
+  name: database_rewinder
+  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'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !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: In Service Asynchronous Job Scheduler for Rails. This gem handles ActiveRecord
+  model as schedule definition.
+email:
+- kakyoin.hierophant@gmail.com
+executables:
+- crono_trigger
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- crono_trigger.gemspec
+- exe/crono_trigger
+- gemfiles/activerecord-42.gemfile
+- gemfiles/activerecord-50.gemfile
+- gemfiles/activerecord-51.gemfile
+- lib/crono_trigger.rb
+- lib/crono_trigger/cli.rb
+- lib/crono_trigger/polling_thread.rb
+- lib/crono_trigger/railtie.rb
+- lib/crono_trigger/schedulable.rb
+- lib/crono_trigger/version.rb
+- lib/crono_trigger/worker.rb
+- lib/generators/crono_trigger/migration/migration_generator.rb
+- lib/generators/crono_trigger/migration/templates/create_table_migration.rb
+- lib/generators/crono_trigger/migration/templates/migration.rb
+- lib/generators/crono_trigger/model/model_generator.rb
+- lib/generators/crono_trigger/model/templates/model.rb
+homepage: https://github.com/joker1007/crono_trigger
+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.6.11
+signing_key: 
+specification_version: 4
+summary: In Service Asynchronous Job Scheduler for Rails
+test_files: []