daemon_runner 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 113e941352f0f027e74475522fbf103a2e2ab2b2
-  data.tar.gz: c0fe5567cab12d9db836c618a52295a7a1e4e5d2
+  metadata.gz: d36f55746d2502664fad4104b312003f1b473b95
+  data.tar.gz: 6729f091a55d2ee3ebee5d0e72788589b88367c0
 SHA512:
-  metadata.gz: a72c199d673e3edcb3af7ea87c307ea85325a76441eaa7aca735d76a30a6f4589e26cd87343fe5cbef7a20d10345d30da3bf830d3554d3d7620a3d7a9f5cdab9
-  data.tar.gz: bd0fa329b8ebea978f1344e63eccf15cb416c3770f573d3fd73d0fb35cf2049c670400bd7212a694dcbd6e9226238f35cf2cf997c6481b298b6b71eb44d01642
+  metadata.gz: 6eaa76309f8b31a68ceb7ce508e7047c050fee14215f7330c28bf551f88c190bbcd37f3106aea7f595178441ab8560a5dcbffe852bf8a62fa0a75b515826a0d3
+  data.tar.gz: af1b9a90f5b429831c47b6df4091e175c493137d01b147bc9e43e1fce25e136167b0e64dade105b0884342e43ee25033ed8f8ade57fcbe22e27e4cb315a7a3b1

data/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

data/README.md

@@ -40,6 +40,8 @@ In order to use this gem you must subclass `DaemonRunner::Client` and add a few
     * :error_sleep_time - Number of seconds to sleep before retying a failed task (**optional**, _default_: 5 seconds)
     * :post_task_sleep_time - Number of seconds to sleep after each task (**optional**, _default_: 1 seconds)
 
+* `schedule` - How often the task should run. See [Scheduling](#scheduling) below. (**optional**)
+
 ### Example
 
 ```ruby
@@ -102,6 +104,49 @@ service = MyService::Client.new(options)
 service.start!
 ```
 
+### Scheduling
+Tasks can define the schedule that they run on and how their schedule is executed.
+To do this, define a method named `schedule` with an array formatted as:
+
+```ruby
+  [:schedule_type, duration]
+```
+
+For example, if you wanted your task to run every 5 minutes, you would do the
+following:
+
+```ruby
+#!/usr/bin/env ruby
+
+class MyService
+  class Tasks
+    class Quiz
+      def schedule
+        [:every, '5m']
+      end
+
+      def run!(args)
+        puts args
+        args
+      end
+    end
+  end
+end
+```
+
+This would execute the `run!` method every 5 minutes. Duration can be defined as a
+string in the `'<number>s/m/h/d/w'` format or as a number of seconds. Schedule types
+are `:in, :at, :every, :cron, :interval`. See rufus-scheduler's
+[README](https://github.com/jmettraux/rufus-scheduler#in-at-every-interval-cron)
+for more information.
+
+The default for tasks that don't explicitly define a schedule is
+
+```ruby
+def schedule
+  [:interval, options[:loop_sleep_time]]
+end
+```
 
 ## Development
 

data/daemon_runner.gemspec

@@ -20,9 +20,12 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "logging", "~> 2.1"
   spec.add_dependency "mixlib-shellout", "~> 2.2"
+  spec.add_dependency "diplomat", "~> 1.0"
+  spec.add_dependency "rufus-scheduler", "~> 3.2"
 
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "yard", "~> 0.8.7"
+  spec.add_development_dependency "dev-consul", "~> 0.6.4"
 end

data/examples/example1.rb

@@ -16,6 +16,10 @@ end
 class MyService
   class Tasks
     class Bar
+      def schedule
+        [:cron, '*/1 * * * *']
+      end
+
       def run!(name)
         puts name
         name
@@ -28,6 +32,10 @@ class MyService
   class Tasks
     class Baz
       class << self
+        def schedule
+          [:interval, 10]
+        end
+
         def run!(args)
           name = args[0]
           reason = args[1]
@@ -40,13 +48,28 @@ class MyService
   end
 end
 
+class MyService
+  class Tasks
+    class Quiz
+      def schedule
+        [:interval, '30s']
+      end
+      def foo!(args)
+        puts 'Firing error'
+        sargs
+      end
+    end
+  end
+end
+
 class MyService
   class Client < DaemonRunner::Client
     def tasks
       [
         [::MyService::Tasks::Foo.new, 'run!'],
         [::MyService::Tasks::Bar.new, 'run!', 'bar'],
-        [::MyService::Tasks::Baz, 'run!', 'baz', 'because']
+        [::MyService::Tasks::Baz, 'run!', 'baz', 'because'],
+        [::MyService::Tasks::Quiz.new, 'foo!', 'blarg', 'assdg']
       ]
     end
   end

data/lib/daemon_runner.rb

@@ -2,3 +2,4 @@ require_relative 'daemon_runner/version'
 require_relative 'daemon_runner/logger'
 require_relative 'daemon_runner/client'
 require_relative 'daemon_runner/shell_out'
+require_relative 'daemon_runner/session'

data/lib/daemon_runner/client.rb

@@ -1,3 +1,5 @@
+require 'rufus-scheduler'
+
 module DaemonRunner
   class Client
     include Logger
@@ -9,6 +11,22 @@ module DaemonRunner
 
     def initialize(options)
       @options = options
+
+      # Set error handling
+      # @param [Rufus::Scheduler::Job] job job that raised the error
+      # @param [RuntimeError] error the body of the error
+      def scheduler.on_error(job, error)
+        error_sleep_time = job[:error_sleep_time]
+        logger = job[:logger]
+        task_id = job[:task_id]
+
+        logger.error "#{task_id}: #{error}"
+        logger.debug "#{task_id}: Suspending #{task_id} for #{error_sleep_time} seconds"
+        job.pause
+        sleep error_sleep_time
+        logger.debug "#{task_id}: Resuming #{task_id}"
+        job.resume
+      end
     end
 
     # Hook to allow initial setup tasks before running tasks.
@@ -33,7 +51,14 @@ module DaemonRunner
       This must be an array of methods for the runner to call'
     end
 
-    # @return [Fixnum] Number of seconds to sleep between loop interations.
+    # @return [Array<Symbol, String/Fixnum>] Schedule tuple-like with the type of schedule and its timing.
+    def schedule
+      # The default type is an `interval` which trigger, execute and then trigger again after
+      # the interval has elapsed.
+      [:interval, loop_sleep_time]
+    end
+
+    # @return [Fixnum] Number of seconds to sleep between loop interactions.
     def loop_sleep_time
       return @loop_sleep_time unless @loop_sleep_time.nil?
       @loop_sleep_time = if options[:loop_sleep_time].nil?
@@ -68,22 +93,16 @@ module DaemonRunner
     def start!
       wait
 
-      loop do # Loop on tasks
-        logger.warn 'Tasks list is empty' if tasks.empty?
-        tasks.each do |task|
-          run_task(task)
-          sleep post_task_sleep_time
-        end
-
-        sleep loop_sleep_time
+      logger.warn 'Tasks list is empty' if tasks.empty?
+      tasks.each do |task|
+        run_task(task)
+        sleep post_task_sleep_time
       end
 
-    rescue StandardError => e
-      # Don't exit the process if initialization fails.
-      logger.error(e)
-
-      sleep error_sleep_time
-      retry
+      scheduler.join
+    rescue SystemExit, Interrupt
+      logger.info 'Shutting down'
+      scheduler.shutdown
     end
 
     private
@@ -103,30 +122,76 @@ module DaemonRunner
                          end
 
       out[:method] = task[1]
+
+      out[:task_id] = if out[:instance].respond_to?(:task_id)
+        out[:instance].send(:task_id).to_s
+      else
+        "#{out[:class_name]}.#{out[:method]}"
+      end
+      raise ArgumentError, 'Invalid task id' if out[:task_id].nil? || out[:task_id].empty?
+
       out[:args] = task[2..-1].flatten
       out
     end
 
+    # @private
+    # @param [Class] instance an instance of the task class
+    # @return [Hash<Symbol, String>] schedule parsed in parts: Schedule type and timing
+    def parse_schedule(instance)
+      valid_types = [:in, :at, :every, :interval, :cron]
+      out = {}
+      task_schedule = if instance.respond_to?(:schedule)
+        instance.send(:schedule)
+      else
+        schedule
+      end
+
+      raise ArgumentError, 'Malformed schedule definition, should be [TYPE, DURATION]' if task_schedule.length < 2
+      raise ArgumentError, 'Invalid schedule type' unless valid_types.include?(task_schedule[0].to_sym)
+
+      out[:type] = task_schedule[0].to_sym
+      out[:schedule] = task_schedule[1]
+      out
+    end
+
     # @private
     # @param [Array<String, String, Array>] task to run
     # @return [String] output returned from task
     def run_task(task)
       parsed_task = parse_task(task)
       instance = parsed_task[:instance]
+      schedule = parse_schedule(instance)
       class_name = parsed_task[:class_name]
       method = parsed_task[:method]
       args = parsed_task[:args]
-      log_line = "Running #{class_name}.#{method}"
-      log_line += "(#{args})" unless args.empty?
-      logger.debug log_line
-
-      out = if args.empty?
-              instance.send(method.to_sym)
-            else
-              instance.send(method.to_sym, args)
-            end
-      logger.debug "Got: #{out}"
-      out
+      task_id = parsed_task[:task_id]
+
+      # Schedule the task
+      schedule_log_line = "#{task_id}: Scheduling job #{class_name}.#{method} as `:#{schedule[:type]}` type"
+      schedule_log_line += " with schedule: #{schedule[:schedule]}"
+      logger.debug schedule_log_line
+
+      scheduler.send(schedule[:type], schedule[:schedule], :overlap => false, :job => true) do |job|
+        log_line = "#{task_id}: Running #{class_name}.#{method}"
+        log_line += "(#{args})" unless args.empty?
+        logger.debug log_line
+
+        job[:error_sleep_time] = error_sleep_time
+        job[:logger] = logger
+        job[:task_id] = task_id
+
+        out = if args.empty?
+          instance.send(method.to_sym)
+        else
+          instance.send(method.to_sym, args)
+        end
+        logger.debug "#{task_id}: Got: #{out}"
+      end
+    end
+
+    # @return [Rufus::Scheduler] A scheduler instance
+    def scheduler
+      @scheduler ||= ::Rufus::Scheduler.new
     end
   end
 end

data/lib/daemon_runner/session.rb

@@ -0,0 +1,125 @@
+require 'diplomat'
+
+module DaemonRunner
+  #
+  # Manage distributed locks with Consul
+  #
+  class Session
+    include Logger
+
+    class << self
+      attr_reader :session
+
+      def start(name, **options)
+        @session ||= Session.new(name, options).renew!
+      end
+
+
+      # Acquire a lock with the current session, or initialize a new session
+      #
+      # @param path [String]  A path in the Consul key-value space to lock
+      # @param lock_session [Session] The Session instance to lock the lock to
+      # @return [Boolean] `true` if the lock was acquired
+      #
+      def lock(path)
+        Diplomat::Lock.acquire(path, session.id)
+      end
+
+      # Release a lock held by the current session
+      #
+      # @param path [String]  A path in the Consul key-value space to release
+      # @param lock_session [Session] The Session instance that the lock was acquired with
+      #
+      def release(path)
+        Diplomat::Lock.release(path, session.id)
+      end
+    end
+
+    # Consul session ID
+    attr_reader :id
+
+    # Session name
+    attr_reader :name
+
+    # Period, in seconds, after which session expires
+    attr_reader :ttl
+
+    # Period, in seconds, that a session's locks will be
+    attr_reader :delay
+
+    # Behavior when a session is invalidated, can be set to either release or delete
+    attr_reader :behavior
+
+    # @param name [String]  Session name
+    # @option options [Fixnum]  ttl (15)    Session TTL in seconds
+    # @option options [Fixnum]  delay (15)  Session release dealy in seconds
+    # @option options [String]  behavior (release)  Session release behavior
+    def initialize(name, **options)
+      logger.info('Initializing a Consul session')
+
+      @name = name
+      @ttl = options.fetch(:ttl, 15)
+      @delay = options.fetch(:delay, 15)
+      @behavior = options.fetch(:behavior, 'release')
+
+      init
+    end
+
+    # Check if there is an active renew thread
+    #
+    # @return [Boolean] `true` if the thread is alive
+    def renew?
+      @renew.is_a?(Thread) && @renew.alive?
+    end
+
+    # Create a thread to periodically renew the lock session
+    #
+    def renew!
+      return if renew?
+
+      @renew = Thread.new do
+        ## Wakeup every TTL/2 seconds and renew the session
+        loop do
+          sleep ttl / 2
+
+          begin
+            logger.debug(" - Renewing Consul session #{id}")
+            Diplomat::Session.renew(id)
+
+          rescue Faraday::ResourceNotFound
+            logger.warn("Consul session #{id} has expired!")
+
+            init
+          rescue StandardError => e
+            ## Keep the thread from exiting
+            logger.error(e)
+          end
+        end
+      end
+
+      self
+    end
+
+    # Stop the renew thread and destroy the session
+    #
+    def destroy!
+      @renew.kill if renew?
+      Diplomat::Session.destroy(id)
+    end
+
+    private
+
+    # Initialize a session and store it's ID
+    #
+    def init
+      @id = Diplomat::Session.create(
+        :Name => name,
+        :TTL => "#{ttl}s",
+        :LockDelay => "#{delay}s",
+        :Behavior => behavior
+      )
+
+      logger.info(" - Initialized a Consul session #{id}")
+    end
+  end
+end

data/lib/daemon_runner/shell_out.rb

@@ -3,17 +3,30 @@ require 'mixlib/shellout'
 module DaemonRunner
   class ShellOut
     attr_reader :runner, :stdout
-    attr_reader :command, :cwd, :timeout, :wait
+    attr_reader :command, :cwd, :timeout, :wait, :valid_exit_codes
+
+    # Wait for the process with the given pid to finish
+    # @param pid [Fixnum] the pid to wait on
+    # @param flags [Fixnum] flags to Process.wait2
+    # @return [Process::Status, nil] the process status or nil if no process was found
+    def self.wait2(pid = nil, flags = 0)
+      return nil if pid.nil?
+      Process.wait2(pid, flags)[1]
+    rescue Errno::ECHILD
+      nil
+    end
 
     # @param command [String] the command to run
     # @param cwd [String] the working directory to run the command
     # @param timeout [Fixnum] the command timeout
     # @param wait [Boolean] wheather to wait for the command to finish
-    def initialize(command: nil, cwd: '/tmp', timeout: 15, wait: true)
+    # @param valid_exit_codes [Array<Fixnum>] exit codes that aren't flagged as failures
+    def initialize(command: nil, cwd: '/tmp', timeout: 15, wait: true, valid_exit_codes: [0])
       @command = command
       @cwd = cwd
       @timeout = timeout
       @wait = wait
+      @valid_exit_codes = valid_exit_codes
     end
 
     # Run command
@@ -27,6 +40,13 @@ module DaemonRunner
       end
     end
 
+    # Wait for the process to finish
+    # @param flags [Fixnum] flags to Process.wait2
+    # @return [Process::Status, nil] the process status or nil if no process was found
+    def wait2(flags = 0)
+      self.class.wait2(@pid, flags)
+    end
+
     private
 
     # Run a command and wait for it to finish
@@ -45,9 +65,10 @@ module DaemonRunner
     # @return [Fixnum] process id
     def run_and_detach
       log_r, log_w = IO.pipe
-      Process.spawn(command, pgroup: true, err: :out, out: log_w)
+      @pid = Process.spawn(command, pgroup: true, err: :out, out: log_w)
       log_r.close
       log_w.close
+      @pid
     end
 
     # Validate command is defined before trying to start the command
@@ -74,6 +95,7 @@ module DaemonRunner
     # @return [Mixlib::ShellOut] client
     def runner
       @runner ||= Mixlib::ShellOut.new(command, :cwd => cwd, :timeout => timeout)
+      @runner.valid_exit_codes = valid_exit_codes
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: daemon_runner
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Andrew Thompson
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-12 00:00:00.000000000 Z
+date: 2016-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logging
@@ -38,6 +38,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: diplomat
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rufus-scheduler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.7
+- !ruby/object:Gem::Dependency
+  name: dev-consul
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.4
 description: 
 email:
 - Andrew_Thompson@rapid7.com
@@ -101,6 +143,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".editorconfig"
 - ".gitignore"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
@@ -116,6 +159,7 @@ files:
 - lib/daemon_runner.rb
 - lib/daemon_runner/client.rb
 - lib/daemon_runner/logger.rb
+- lib/daemon_runner/session.rb
 - lib/daemon_runner/shell_out.rb
 - lib/daemon_runner/version.rb
 homepage: https://github.com/rapid7/daemon_runner/