chutzen 0.8.0

data/lib/chutzen/watcher.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Chutzen
+  # Watches the current process to make sure it's still running as intended.
+  #
+  # You can set a watcher to make sure a list of files increases in size at
+  # least every ‘read_timeout’ seconds.
+  #
+  #   watcher = Watcher.new(
+  #     fail_when: {
+  #       'read_timeout' => 2,
+  #       'runtime' => 60
+  #     },
+  #     files: [file]
+  #   )
+  #   until watcher.done?
+  #     watcher.tick
+  #   end
+  class Watcher
+    class Error < StandardError
+    end
+
+    attr_reader :read_timeout, :runtime
+
+    def initialize(fail_when: nil, files: nil)
+      fail_when&.each do |name, value|
+        instance_variable_set("@#{name}", value)
+      end
+      @started_at = now
+      @files = files
+      reset
+    end
+
+    def select_timeout
+      return @select_timeout if defined?(@select_timeout)
+
+      minimal_timeout = [read_timeout, runtime].compact.min
+      return unless minimal_timeout
+
+      minimal_timeout / 2.0
+    end
+
+    def done?
+      # Because demuxers and the watcher share an interface we need to the
+      # watcher to explain the thread doesn't have to wait for it.
+      true
+    end
+
+    # Raises an exception when any of the failure conditions is reached.
+    def tick
+      compute_last_read
+      verify_last_read
+      verify_runtime
+    end
+
+    private
+
+    def total_bytes_read
+      return unless @files
+
+      @files.inject(0) { |total, file| total + file.size }
+    end
+
+    def last_read_ago
+      now - @last_read_at
+    end
+
+    def compute_last_read
+      return unless read_timeout && @files
+
+      bytes_read = total_bytes_read
+      @last_read_at = now if bytes_read != @bytes_read
+      @bytes_read = bytes_read
+    end
+
+    def verify_last_read
+      return unless read_timeout && @files
+      return if last_read_ago < read_timeout
+
+      raise(
+        Error,
+        "Command did not write to its output for more than #{read_timeout} " \
+        'seconds.'
+      )
+    end
+
+    def ran
+      now - @started_at
+    end
+
+    def verify_runtime
+      return unless runtime
+      return if ran < runtime
+
+      raise(
+        Error,
+        "Command did not finish within the alotted runtime #{runtime} " \
+        'seconds.'
+      )
+    end
+
+    def reset
+      @last_read_at = now
+      @bytes_read = 0
+    end
+
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/chutzen/worker.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'sidekiq'
+
+module Chutzen
+  # Sidekiq worker to perform a Chutzen job expressed in JSON.
+  class Worker
+    include Sidekiq::Worker
+
+    sidekiq_options queue: Chutzen.sidekiq_queue
+
+    def perform(json)
+      Chutzen.perform(JSON.parse(json))
+    end
+  end
+end

data/lib/chutzen.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'sidekiq/api'
+
+# Disabled to allow optional loading of the New Relic gem.
+# rubocop:disable Lint/SuppressedException
+begin
+  require 'newrelic_rpm'
+rescue LoadError
+end
+# rubocop:enable Lint/SuppressedException
+
+# Implements a toolkit to perform batch processing.
+module Chutzen
+  autoload :Apply, 'chutzen/apply'
+  autoload :Command, 'chutzen/command'
+  autoload :Demux, 'chutzen/demux'
+  autoload :Dictionary, 'chutzen/dictionary'
+  autoload :Expression, 'chutzen/expression'
+  autoload :ExpressionParser, 'chutzen/expression_parser'
+  autoload :Job, 'chutzen/job'
+  autoload :Notification, 'chutzen/notification'
+  autoload :RuntimeError, 'chutzen/runtime_error'
+  autoload :Shell, 'chutzen/shell'
+  autoload :Signal, 'chutzen/signal'
+  autoload :StandardError, 'chutzen/standard_error'
+  autoload :Template, 'chutzen/template'
+  autoload :TemplateParser, 'chutzen/template_parser'
+  autoload :VERSION, 'chutzen/version'
+  autoload :Watcher, 'chutzen/watcher'
+  autoload :Worker, 'chutzen/worker'
+
+  class << self
+    attr_accessor :sidekiq_queue
+  end
+  self.sidekiq_queue = 'chutzen'
+
+  # Enqueue a Sidekiq job that will eventually perform the job in the
+  # description.
+  def self.perform_async(description)
+    Chutzen::Worker.perform_async(JSON.dump(description))
+  end
+
+  # Enqueue a Sidekiq job that will eventually process the signal. It's
+  # customary for each Chutzen host to have its own control queue next to
+  # the regular job queue. Use the name of that queue when you want to
+  # target a specific host. Otherwise the signal will be processed by one
+  # random host.
+  #
+  # @example Stop chutzen-1-staging
+  #   Chutzen.emit_signal('stop', queue: 'chutzen-1-staging')
+  def self.emit_signal(signal, queue:, expires_at: nil, expires_in: nil)
+    Chutzen::Signal.set(
+      queue: queue
+    ).perform_async(
+      signal,
+      expiration_since_epoch(
+        expires_at: expires_at,
+        expires_in: expires_in
+      )
+    )
+  end
+
+  # Dequeue all jobs that match the query. Uses Chutzen's own query format.
+  def self.dequeue(query)
+    Sidekiq::Queue.new(sidekiq_queue).each do |job|
+      dictionary = Chutzen::Dictionary.new(JSON.parse(job.args.first))
+      expression = Chutzen::Expression.new(query, dictionary)
+      job.delete if expression.result
+    end
+  end
+
+  # Immediately perform the description.
+  def self.perform(description)
+    Chutzen::Job.new(description).perform
+  end
+
+  # Computes the expiration in seconds since epoch. When neither expires_at
+  # or expires_in is specified it will default to 30 seconds from now.
+  def self.expiration_since_epoch(expires_at: nil, expires_in: nil)
+    return expires_at.to_i if expires_at
+
+    expires_in ||= 30
+    (Time.now + expires_in).to_i
+  end
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: chutzen
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- Manfred Stienstra
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: newrelic_rpm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '6.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '6.10'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: |
+  Chutzen is a toolkit to implement batch processing for your Ruby or
+  Ruby on Rails application.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/chutzen.rb
+- lib/chutzen/apply.rb
+- lib/chutzen/command.rb
+- lib/chutzen/command/execution_failed.rb
+- lib/chutzen/demux.rb
+- lib/chutzen/dictionary.rb
+- lib/chutzen/expression.rb
+- lib/chutzen/expression/lookup_error.rb
+- lib/chutzen/expression/syntax_error.rb
+- lib/chutzen/expression_parser.rb
+- lib/chutzen/job.rb
+- lib/chutzen/notification.rb
+- lib/chutzen/runtime_error.rb
+- lib/chutzen/shell.rb
+- lib/chutzen/signal.rb
+- lib/chutzen/standard_error.rb
+- lib/chutzen/template.rb
+- lib/chutzen/template/syntax_error.rb
+- lib/chutzen/template_parser.rb
+- lib/chutzen/version.rb
+- lib/chutzen/watcher.rb
+- lib/chutzen/worker.rb
+homepage:
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Toolkit to implement batch processing.
+test_files: []