crono_trigger 0.3.2 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d12624dcc2f27a3f0bc7c83544ae735490c8d4294587fe6fce6b16661d934c1
-  data.tar.gz: 931bd6e1dcba7a0a77f644235d74f762f3587e65b17a36a1bb9bf962b8e27a9e
+  metadata.gz: 035751ab4333491a769367b5d28fbace76bcb70806400cc10f6338c89b65e394
+  data.tar.gz: '0917037bd6064a166b2ff0a95d7ffa094e44a7ed54c8b08f120e593df41660bc'
 SHA512:
-  metadata.gz: aee050331778f7db89628d332efc7c4cfe7965dc2a8b19f6bd1eaa678045f5fe5b64042ba3b7511bee542f9b310debdd65728694e2c4f07b94bd1c362a80370a
-  data.tar.gz: ef25f44ecdc3afc9dab964ffa9d82ff455d02fe26d96614951df75b764a9067cbc177083bbbb4f39071e6d3208a99cd924613b04b26866d09506eb56f8360d9e
+  metadata.gz: 27bd18f70a271450c1c316d3cdf10b837f1b0322026a72788373633be3743d20719654e40e2dba528f2b2f178deee893930a6a208984709bafcf3e40d9bb7ae7
+  data.tar.gz: 142f7e3a5fc634c81142bb254dae96e20a20d6efb6fb6a425ca01f7d77af2a89f43073296ce901127c4fef6fab9a4c5b6b679fd8033b0d019c3a79c8e490ad82

data/.travis.yml

@@ -2,10 +2,9 @@ sudo: false
 language: ruby
 cache: bundler
 rvm:
-  - 2.5.0
+  - 2.5.1
   - 2.4.3
 gemfile:
-  - gemfiles/activerecord-50.gemfile
   - gemfiles/activerecord-51.gemfile
   - gemfiles/activerecord-52.gemfile
 before_install:

data/README.md

@@ -25,6 +25,28 @@ Or install it yourself as:
 
     $ gem install crono_trigger
 
+## Update from v0.3.x
+
+### Create crono_trigger system tables
+```
+$ rails g crono_trigger:install # => create migrations
+$ rake db:migrate
+```
+
+### Add `locked_by:string` column to CronoTrigger::Schedulable model
+```
+$ rails g migration add_locked_by_column_to_your_model
+$ rake db:migrate
+```
+
+```ruby
+class AddLockedByColumnToYourModel < ActiveRecord::Migration[5.2]
+  def change
+    add_column :your_models, :locked_by, :string
+  end
+end
+```
+
 ## Usage
 
 #### Execute `crono_trigger:model` generator.
@@ -154,6 +176,24 @@ Usage: crono_trigger [options] MODEL [MODEL..]
 You can rename some columns.
 ex. `crono_trigger_options[:next_execute_at_column_name] = "next_time"`
 
+## Admin Web
+
+![screenshots/crono_trigger_web.jpg](screenshots/crono_trigger_web.jpg)
+
+### Standalone mode
+
+```
+$ crono_trigger-web --rails
+```
+
+### Mount as Rack app
+
+```ruby
+# config/routes.rb
+require "crono_trigger/web"
+mount CronoTrigger::Web => '/crono_trigger'
+```
+
 ## Rollbar integration
 This gem has rollbar plugin.
 If `crono_trigger/rollbar` is required, Add Rollbar logging process to `CronoTrigger.config.error_handlers`

data/Rakefile

@@ -9,6 +9,23 @@ pwd = File.expand_path('../', __FILE__)
 
 gemfiles = Dir.glob(File.join(pwd, "gemfiles", "*.gemfile")).map { |f| File.basename(f, ".*") }
 
+namespace :js do
+  task :clean do
+    rm_r(File.join(pwd, "web", "app", "build")) if File.exist?(File.join(pwd, "web", "app", "build"))
+    rm_r(File.join(pwd, "web", "public"))
+  end
+
+  task build: [:clean] do
+    Dir.chdir(File.join(pwd, "web", "app"))
+    sh({"PUBLIC_URL" => "<%= URI.parse(url('/')).path.chop %>"}, "npm run build") do |ok, res|
+      raise "failed to build JS" unless ok
+
+      mv(File.join(pwd, "web", "app", "build"), File.join(pwd, "web", "public"))
+      mv(File.join(pwd, "web", "public", "index.html"), File.join(pwd, "web", "views", "index.erb"))
+    end
+  end
+end
+
 namespace :spec do
   gemfiles.each do |gemfile|
     desc "Run Tests by #{gemfile}.gemfile"

data/crono_trigger.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |spec|
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
+    f.match(%r{^(test|spec|features|screenshots)/})
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
@@ -26,6 +26,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency "serverengine"
   spec.add_dependency "concurrent-ruby"
   spec.add_dependency "tzinfo"
+  spec.add_dependency "sinatra"
+  spec.add_dependency "rack-contrib"
+  spec.add_dependency "oj"
   spec.add_dependency "activerecord", ">= 4.2"
 
   spec.add_development_dependency "sqlite3"

data/exe/crono_trigger-web

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require "crono_trigger/web"
+
+options = {
+  bind: "0.0.0.0",
+  port: 9292
+}
+
+opt_parser = OptionParser.new do |o|
+  o.on('-p', '--port=PORT', 'Set port number (Default: 9292)') { |port| options[:port] = port.to_i }
+  o.on('-b', '--bind=ADRESS', 'Set address to bind (Default: 0.0.0.0)') { |addr| options[:bind] = addr }
+  o.on('-s', '--server=SERVER', 'Set Rack server handler name') { |handler| options[:server] = handler }
+  o.on('--rails', 'Require rails environment') do
+    pwd = Dir.pwd
+    loader = -> do
+      begin
+        require File.join(pwd, "config", "environment")
+        Rails.application.eager_load!
+      rescue LoadError
+        raise if pwd == "/"
+        pwd = File.expand_path("..", pwd)
+        loader.call
+      end
+    end
+    loader.call
+  end
+end
+
+opt_parser.parse!
+
+CronoTrigger::Web.run!(options)

data/lib/crono_trigger.rb

@@ -1,18 +1,22 @@
 require "crono_trigger/version"
 
 require "ostruct"
+require "socket"
 require "active_record"
 require "concurrent"
+require "crono_trigger/models/worker"
+require "crono_trigger/models/signal"
 require "crono_trigger/worker"
 require "crono_trigger/polling_thread"
 require "crono_trigger/schedulable"
 
 module CronoTrigger
   @config = OpenStruct.new(
-    polling_thread: 1,
+    worker_id: Socket.ip_address_list.detect { |info| !info.ipv4_loopback? && !info.ipv6_loopback? }.ip_address,
+    polling_thread: nil,
     polling_interval: 5,
     executor_thread: 25,
-    model_names: [],
+    model_names: nil,
     error_handlers: [],
   )
 
@@ -24,12 +28,26 @@ module CronoTrigger
     yield config
   end
 
+  def self.reloader
+    @reloader
+  end
+
+  def self.reloader=(reloader)
+    @reloader = reloader
+  end
+
+  self.reloader = proc { |&block| block.call }
+
   def self.load_config(yml, environment = nil)
     config = YAML.load_file(yml)[environment || "default"]
     config.each do |k, v|
       @config[k] = v
     end
   end
+
+  def self.workers
+    CronoTrigger::Models::Worker.alive_workers
+  end
 end
 
 if defined?(Rails)

data/lib/crono_trigger/cli.rb

@@ -8,7 +8,11 @@ options = {
 }
 
 opt_parser = OptionParser.new do |opts|
-  opts.banner = "Usage: crono_trigger [options] MODEL [MODEL..]"
+  opts.banner = "Usage: crono_trigger [options] [MODEL..]\n  If MODEL is not given, Search classes including CronoTrigger::Schedulable module automatically."
+
+  opts.on("-w", "--worker-id=ID", "Worker ID (default: First local ip address which is not loopback") do |id|
+    options[:worker_id] = id
+  end
 
   opts.on("-f", "--config-file=CONFIG", "Config file (ex. ./crono_trigger.rb)") do |cfg|
     options[:config] = cfg
@@ -18,7 +22,7 @@ opt_parser = OptionParser.new do |opts|
     options[:env] = env
   end
 
-  opts.on("-p", "--polling-thread=SIZE", Integer, "Polling thread size (Default: 1)") do |i|
+  opts.on("-p", "--polling-thread=SIZE", Integer, "Polling thread size (Default: Min of (target model count or processor_count)") do |i|
     options[:polling_thread] = i
   end
 
@@ -56,6 +60,7 @@ opt_parser.parse!
 
 begin
   require "rails"
+  require "crono_trigger/railtie"
   require File.expand_path("./config/environment", Rails.root)
 rescue LoadError
 end
@@ -66,7 +71,7 @@ CronoTrigger.load_config(options[:config], options[:env]) if options[:config]
   CronoTrigger.config[name] = options[name] if options[name]
 end
 
-CronoTrigger.config.model_names.concat(ARGV)
+CronoTrigger.config.model_names = ARGV
 
 se = ServerEngine.create(nil, CronoTrigger::Worker, {
   daemonize: options[:daemonize],

data/lib/crono_trigger/models/signal.rb

@@ -0,0 +1,52 @@
+module CronoTrigger
+  module Models
+    class Signal < ActiveRecord::Base
+      self.table_name = "crono_trigger_signals"
+
+      IGNORE_THRESHOLD = 300
+
+      enum signal: {TERM: "TERM", USR1: "USR1", CONT: "CONT", TSTP: "TSTP"}
+
+      scope :sent_to_me, proc {
+        raise "Must set worker_id" unless CronoTrigger.config.worker_id
+
+        where(arel_table[:sent_at].gteq(Time.current - IGNORE_THRESHOLD))
+          .where(worker_id: CronoTrigger.config.worker_id)
+          .where(received_at: nil)
+          .order(:sent_at)
+      }
+
+      class << self
+        def send_signal(signal, worker_id)
+          create!(signal: signal, worker_id: worker_id, sent_at: Time.current)
+        end
+
+        def send_term(worker_id)
+          send_signal("TERM", worker_id)
+        end
+
+        def send_usr1(worker_id)
+          send_signal("USR1", worker_id)
+        end
+
+        def send_cont(worker_id)
+          send_signal("CONT", worker_id)
+        end
+
+        def send_tstp(worker_id)
+          send_signal("TSTP", worker_id)
+        end
+      end
+
+      def kill_me(to_supervisor: true)
+        if update(received_at: Time.current)
+          if to_supervisor && Process.ppid != 1
+            Process.kill(signal, Process.ppid)
+          else
+            Process.kill(signal, Process.pid)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/crono_trigger/models/worker.rb

@@ -0,0 +1,16 @@
+require "crono_trigger/worker"
+
+module CronoTrigger
+  module Models
+    class Worker < ActiveRecord::Base
+      self.table_name = "crono_trigger_workers"
+
+      ALIVE_THRESHOLD = CronoTrigger::Worker::HEARTBEAT_INTERVAL * 5
+
+      enum executor_status: {running: "running", quiet: "quiet", shuttingdown: "shuttingdown", shutdown: "shutdown"}
+      serialize :polling_model_names, JSON
+
+      scope :alive_workers, proc { where(arel_table[:last_heartbeated_at].gteq(Time.current - ALIVE_THRESHOLD)) }
+    end
+  end
+end

data/lib/crono_trigger/polling_thread.rb

@@ -1,25 +1,32 @@
 module CronoTrigger
   class PollingThread
-    def initialize(model_queue, stop_flag, logger, executor)
+    def initialize(model_queue, stop_flag, logger, executor, execution_counter)
       @model_queue = model_queue
       @stop_flag = stop_flag
       @logger = logger
       @executor = executor
+      @execution_counter = execution_counter
+      @quiet = Concurrent::AtomicBoolean.new(false)
     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
+          next if quiet?
+
+          CronoTrigger.reloader.call do
+            begin
+              model_name = @model_queue.pop(true)
+              model = model_name.classify.constantize
+              poll(model)
+            rescue ThreadError => e
+              @logger.error(e) unless e.message == "queue empty"
+            rescue => e
+              @logger.error(e)
+            ensure
+              @model_queue << model_name if model_name
+            end
           end
         end
       end
@@ -29,29 +36,60 @@ module CronoTrigger
       @thread.join
     end
 
+    def quiet
+      @quiet.make_true
+    end
+
+    def quiet?
+      @quiet.true?
+    end
+
+    def alive?
+      @thread.alive?
+    end
+
     def poll(model)
       @logger.debug "(polling-thread-#{Thread.current.object_id}) Poll #{model}"
       records = []
-      primary_key_offset = nil
+      overflowed_record_ids = []
+
       begin
         model.connection_pool.with_connection do
-          records = model.executables_with_lock(primary_key_offset: primary_key_offset)
-          primary_key_offset = records.last && records.last.id
+          records = model.executables_with_lock
         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
+            @executor.post do
+              @execution_counter.increment
               begin
-                record.do_execute
-              rescue Exception => e
-                @logger.error(e)
+                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
+              ensure
+                @execution_counter.decrement
               end
             end
+          rescue Concurrent::RejectedExecutionError
+            overflowed_record_ids << record.id
           end
         end
-      end while records.any?
+        unlock_overflowed_records(model, overflowed_record_ids)
+      end while overflowed_record_ids.empty? && records.any?
+    end
+
+    private def unlock_overflowed_records(model, overflowed_record_ids)
+      model.connection_pool.with_connection do
+        model.where(id: overflowed_record_ids).crono_trigger_unlock_all!
+      end
+    rescue ActiveRecord::ConnectionNotEstablished, ActiveRecord::LockWaitTimeout, ActiveRecord::StatementTimeout, ActiveRecord::Deadlocked
+      sleep 1
+      retry
     end
   end
 end

data/lib/crono_trigger/railtie.rb

@@ -1,4 +1,19 @@
 module CronoTrigger
   class Railtie < ::Rails::Railtie
+    config.after_initialize do
+      CronoTrigger.reloader = CronoTrigger::Railtie::Reloader.new
+    end
+
+    class Reloader
+      def initialize(app = ::Rails.application)
+        @app = app
+      end
+
+      def call
+        @app.reloader.wrap do
+          yield
+        end
+      end
+    end
   end
 end