daemonic 0.0.2 → 0.1.0

data/lib/daemonic/pidfile.rb

@@ -1,64 +0,0 @@
-require 'fileutils'
-
-module Daemonic
-  class Pidfile
-    include FileUtils
-    include Logging
-
-    attr_reader :pid, :config, :index
-
-    def initialize(options = {})
-      @pid      = options.fetch(:pid)
-      @config   = options.fetch(:config)
-      @index    = options[:index]
-    end
-
-    def write
-      mkdir_p(File.dirname(filename))
-
-      if File.exist?(filename)
-        existing_pid = File.open(filename, 'r').read.chomp
-        running = Process.getpgid(existing_pid) rescue false
-        if running
-          fatal "Error: PID file already exists at `#{filename}` and a process with PID `#{existing_pid}` is running"
-          exit 1
-        else
-          debug "Warning: cleaning up stale pid file at `#{filename}`"
-          write!
-        end
-      else
-        debug "Writing pidfile #{filename} with pid #{pid}"
-        write!
-      end
-    end
-
-    def clean
-      if File.exist?(filename)
-        existing_pid = File.open(filename, 'r').read.chomp
-        if existing_pid == pid.to_s
-          debug "Cleaning up my own pid file at `#{filename}`"
-          rm(filename)
-        else
-          debug "Pid file `#{filename}` did not belong to me, so not cleaning. I am #{Process.pid}, and the pid file says #{existing_pid}"
-        end
-      else
-        debug "Pid file disappeared from `#{filename}`"
-      end
-    end
-
-    private
-
-    def filename
-      if index
-        config.pidfile.to_s.sub(/\.([^\.]+)\z/, ".#{index}.\\1")
-      else
-        config.pidfile
-      end
-    end
-
-    def write!
-      File.open(filename, 'w') { |f| f.write(pid) }
-    end
-
-  end
-end

data/lib/daemonic/worker.rb

@@ -1,93 +0,0 @@
-module Daemonic
-  class Worker
-    include Logging
-
-    attr_reader :index, :config
-
-    def initialize(options)
-      @index        = options.fetch(:index)
-      @config       = options.fetch(:config)
-    end
-
-    def start
-      @pid = Process.spawn(
-        {"DAEMON_WORKER_NUMBER" => index.to_s},
-        *Array(config.command),
-        {:chdir => config.working_dir}
-      )
-      sleep 0.1
-      info "#{to_s} Starting."
-      pidfile.write
-      wait_for { running? }
-      info "#{to_s} Started!"
-    end
-
-    def stop
-      Process.kill("TERM", pid)
-      info "#{to_s} Stopping."
-      Process.waitpid(pid)
-    rescue Errno::ECHILD, Errno::ESRCH
-      warn "#{to_s} Already stopped."
-    ensure
-      pidfile.clean
-      @pid = nil
-    end
-
-    def restart
-      info "#{to_s} Restarting."
-      stop
-      start
-    end
-
-    def hup
-      Process.kill("HUP", pid)
-    end
-
-    def monitor
-      if not running?
-        warn "#{to_s} Not running."
-        start
-      end
-    end
-
-    def running?
-      if @pid
-        !Process.waitpid(pid, Process::WNOHANG) rescue false
-      else
-        false
-      end
-    end
-
-    private
-
-    def pid
-      @pid || raise("unknown pid")
-    end
-
-    def pidfile
-      Pidfile.new(
-        pid:       pid,
-        config:    config,
-        index:     index,
-      )
-    end
-
-    def wait_for(timeout=2)
-      deadline = Time.now + timeout
-      until Time.now >= deadline
-        result = yield
-        if result
-          return
-        else
-          sleep 0.1
-        end
-      end
-      warn "#{to_s} It took too long to start."
-    end
-
-    def to_s
-      "<Worker:#{index} pid:#{@pid.inspect} running:#{running?.inspect}>"
-    end
-
-  end
-end

data/test/config

@@ -1,6 +0,0 @@
---workers 5
---pid tmp/test.pid
---name daemon_test
---command "ruby test/test_daemon.rb"
---loglevel debug
---log log/test.log

data/test/crappy_daemon.rb

@@ -1 +0,0 @@
-exit 1

data/test/integration_test.rb

@@ -1,155 +0,0 @@
-require 'minitest/autorun'
-require "thread"
-
-class TestIntegration < MiniTest::Unit::TestCase
-
-  def test_integration
-    master_pid = daemonic %Q|--workers 5 --pid tmp/test.pid --name daemon-test --command "ruby test/test_daemon.rb" --log #{LOGFILE}|
-    perform_tests(master_pid)
-  end
-
-  def test_with_config_file
-    master_pid = daemonic %Q|--config test/config|
-    perform_tests(master_pid)
-  end
-
-  def test_with_failing_daemon
-    master_pid = daemonic %Q|--pid tmp/test.pid --name daemon-test --command "ruby test/crappy_daemon.rb" --log #{LOGFILE}|
-    sleep 0.2
-    wait_for(10) { not running? master_pid }
-  end
-
-  def test_start_daemonic_programmatically
-    $LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
-    require 'daemonic'
-    Thread.new {
-      Daemonic.start(
-        name: "daemon-test",
-        workers: 5,
-        command: "ruby test/test_daemon.rb",
-        logfile: LOGFILE,
-        pidfile: "tmp/test.pid",
-      )
-    }
-    sleep 0.2
-    master_pid = Integer(File.open("tmp/test.pid").read)
-    perform_tests(master_pid)
-  end
-
-  def setup
-    FileUtils.mkdir_p(File.dirname(LOGFILE))
-    FileUtils.rm(LOGFILE) if File.exist?(LOGFILE)
-  end
-
-  def teardown
-    spawned_commands.each { |pid| Process.kill("TERM", pid) }
-  end
-
-  private
-
-  def running?(pid)
-    Process.getpgid(pid) rescue false
-  end
-
-  def perform_tests(master_pid)
-
-    pids_of_workers = []
-    wait_for {
-      pids_of_workers = find_worker_pids
-      pids_of_workers.size == 5
-    }
-
-    sleep 1
-
-    # restart
-    signal "USR2", master_pid
-
-    sleep 1
-
-    wait_for {
-      new_pids_of_workers = find_worker_pids
-      all_are_different?(new_pids_of_workers, pids_of_workers)
-    }
-    assert_equal 5, find_worker_pids.size
-
-    # master pid file
-    file = "tmp/test.pid"
-    assert File.exist?(file), "Missing master pidfile at #{file}"
-
-    # worker pid files
-    (0...5).each do |num|
-      file = "tmp/test.#{num}.pid"
-      assert File.exist?(file), "Missing worker pidfile at #{file}"
-    end
-
-    # increase workers on the fly
-    signal "TTIN", master_pid
-    assert_equal 6, find_worker_pids.size
-
-    # decrease workers on the fly
-    signal "TTOU", master_pid
-    assert_equal 5, find_worker_pids.size
-
-    # monitor crashing workers
-    pid_to_kill = find_worker_pids.first
-    signal "TERM", pid_to_kill
-    sleep 0.2
-    assert_equal 5, find_worker_pids.size
-
-    # shutdown
-    signal "TERM", master_pid
-    workers_remaining = []
-    wait_for {
-      workers_remaining = find_worker_pids
-      workers_remaining.size == 0
-    }
-  end
-
-  SCRIPT_NAME = "test_daemon.rb"
-  LOGFILE = "log/test.log"
-
-  def spawned_commands
-    @spawned_commands ||= []
-  end
-
-  def find_worker_pids
-    find_pids_for(SCRIPT_NAME)
-  end
-
-  def daemonic(command)
-    cmd = "./bin/daemonic #{command}"
-    puts "\n#{cmd}"
-    pid = spawn(cmd)
-    spawned_commands << pid
-    pid
-  end
-
-  def find_pids_for(filter)
-    processes = `ps u`.split("\n")
-    found = processes.select { |line| line.include?(filter) }
-    found.map { |line| line.split(/\s+/, 4)[1].to_i }
-  end
-
-  def signal(type, pid)
-    Process.kill(type, pid)
-    sleep 0.1
-  end
-
-  def wait_for(timeout=10)
-    deadline = Time.now + timeout
-    until Time.now >= deadline
-      result = yield
-      if result
-        return
-      else
-        sleep 0.1
-      end
-    end
-    raise "Timeout expired, running now: #{find_worker_pids.inspect}"
-  end
-
-  def all_are_different?(one, two)
-    (one & two).empty?
-  end
-
-end

data/test/test_daemon.rb

@@ -1,10 +0,0 @@
-exiting = false
-trap("TERM") { exiting = true }
-trap("INT") { exiting = true }
-trap("HUP") { puts "HUP HOLLAND HUP" }
-
-$PROGRAM_NAME = "test_daemon.rb daemon_test worker##{ENV["DAEMON_WORKER_NUMBER"]}"
-
-until exiting
-  sleep 0.1
-end