tiny_daemon 0.0.2

data/.gitignore

@@ -0,0 +1 @@
+tmp/*

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,18 @@
+PATH
+  remote: .
+  specs:
+    tiny_daemon (0.0.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.2.0)
+    rake (10.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  minitest
+  rake
+  tiny_daemon!

data/README.md

@@ -0,0 +1,68 @@
+tiny_daemon
+================
+
+* It daemonizes a Ruby block and supports graceful exiting.
+* It only supports and guarantee running only one process at any moment
+
+
+How to use
+--------------
+
+Please include this into your Gemfile:
+
+```
+gem 'tiny_daemon'
+```
+
+```ruby
+p = TinyDaemon.new("test_process", "pids", "log")
+
+p.stop # Allow only one instance to run at any moment
+
+p.exit do
+  is_running = false
+  puts "The process #{Process.pid} is being killed gracefully "
+end
+
+p.start do
+  while is_running
+    puts "Test"
+    sleep(1)
+  end
+
+  puts "The process #{Process.pid} exited gracefully"
+end
+```
+
+There will be a pid file at pids/test_process.pid. The log file will be at log/test_process.log.
+
+We can issue `kill [pid]` in order to exit the process gracefully. Please note that using `kill -9 [pid]` will terminate the process immediately.
+
+
+Run example
+--------------
+
+1. Install all dependencies: `bundle install`
+2. Run the example: `bundle exec ruby tests/example.rb`
+
+
+Requirement
+--------------
+
+* >= Ruby 2.0
+* *nix platform
+
+
+How to develop
+--------------
+
+1. Install all dependencies: `bundle install`
+2. Run all tests: `bundle exec rake test`
+3. Start developing
+
+
+Author
+--------------
+
+Tanin Na Nakorn
+

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.test_files = FileList['tests/**/*_test.rb']
+  t.verbose = true
+end

data/lib/tiny_daemon.rb

@@ -0,0 +1,127 @@
+require 'tiny_daemon/version'
+require 'tiny_daemon/process_file'
+
+class TinyDaemon
+  attr_accessor :app_name, :pid_dir, :log_dir
+
+  START_TIMEOUT = 5
+  STOP_TIMEOUT = 30
+
+  def initialize(app_name, pid_dir, log_dir)
+    @app_name = app_name
+    @pid_dir = pid_dir
+    @log_dir = log_dir
+  end
+
+  def exit(&block)
+    @exit_block = block
+  end
+
+  def process
+    @process ||= ProcessFile.new(self.app_name, self.pid_dir)
+  end
+
+  def start(&block)
+    raise "#{self.process.pid_file_path} already exists. The process might already run. Remove it manually if it doesn't." if self.process.get
+    
+    Process.fork do
+      Process.daemon(true, true)
+
+      self.process.store(Process.pid)
+      reset_umask
+      set_process_name
+      redirect_io
+
+      if @exit_block
+        trap("TERM") { exit_on_double_signals } # If `kill <pid>` is called, it will be trapped here
+      end
+
+      at_exit { clean_process_file }
+      block.call
+    end
+
+    wait_until_start
+    self.process.get
+  end
+
+  def stop(timeout_secs = STOP_TIMEOUT)
+    pid = self.process.get
+
+    if pid
+      begin
+        Process.kill('TERM', pid)
+      rescue => e
+      end
+
+      wait_until_exit(pid, timeout_secs)
+    end
+  end
+
+  private 
+  def wait_until_start
+    start_time = Time.now.to_i
+    while self.process.get.nil?
+      sleep(0.1)
+
+      if (Time.now.to_i - start_time) > START_TIMEOUT
+        raise "Waiting too long (for #{START_TIMEOUT} seconds) to start. There might be an exception. Please check the log"
+      end
+    end
+  end
+
+  def wait_until_exit(pid, timeout_secs)
+    start_time = Time.now.to_i
+    while true
+      begin
+        Process.kill(0, pid)
+      rescue Errno::ESRCH
+        break # the process doesn't exist anymore
+      rescue ::Exception # for example on EPERM (process exists but does not belong to us)
+      end
+
+      sleep(0.1)
+
+      if (Time.now.to_i - start_time) > timeout_secs
+        raise "Waiting too long (for #{timeout_secs} seconds) to exit."
+      end
+    end
+  end
+
+  def reset_umask
+    File.umask(0000) # We don't want to inherit umask from the parent process
+  end
+
+  def set_process_name
+    $0 = self.app_name # In `ps aux`, it will show this name
+  end
+
+  def log_file
+    File.join(self.log_dir, "#{self.app_name}.log")
+  end
+
+  def redirect_io
+    FileUtils.mkdir_p File.dirname(self.log_dir), :mode => 0755
+    FileUtils.touch log_file
+    File.chmod(0644, log_file)
+    $stdout.reopen(log_file, 'a')
+    $stderr.reopen($stdout)
+    $stdout.sync = true
+  end
+
+  def exit_on_double_signals
+    @kill_count ||= 0
+
+    if @kill_count == 0
+      @kill_count += 1
+      @exit_block.call
+    else
+      clean_process_file
+      puts "TERM is signaled twice. Therefore, we kill the process #{Process.pid} immediately."
+      Kernel.exit(0)
+    end
+  end
+
+  def clean_process_file
+    self.process.clean
+  end
+end

data/lib/tiny_daemon/process_file.rb

@@ -0,0 +1,30 @@
+class TinyDaemon
+  class ProcessFile < Struct.new(:app_name, :pid_dir)
+    def pid_file_path
+      File.join(self.pid_dir, "#{self.app_name}.pid")
+    end
+
+    def store(pid)
+      raise "#{pid_file_path} already exists. The process might already run. Remove it manually if it doesn't." if File.exists?(pid_file_path)
+
+      FileUtils.mkdir_p(self.pid_dir)
+      File.open(pid_file_path, 'w') do |f| 
+        f.write("#{pid}")
+      end
+    end
+
+    def get
+      pid = if File.exists?(pid_file_path)
+        IO.read(pid_file_path).strip.to_i
+      else
+        0
+      end
+
+      pid == 0 ? nil : pid
+    end
+
+    def clean
+      FileUtils.rm(pid_file_path) if File.exists?(pid_file_path)
+    end
+  end
+end

data/lib/tiny_daemon/version.rb

@@ -0,0 +1,3 @@
+class TinyDaemon
+  VERSION = '0.0.2'
+end

data/tests/example.rb

@@ -0,0 +1,22 @@
+$:.push('lib')
+
+require 'tiny_daemon'
+
+is_running = true
+
+daemon = TinyDaemon.new("tiny_daemon_example", "tmp", "tmp")
+daemon.stop
+daemon.exit do
+  is_running = false
+  puts "Being killed gracefully "
+end
+pid = daemon.start do
+  while is_running
+    puts Time.now.to_i.to_s
+    sleep(1)
+  end
+
+  puts "Exit gracefully"
+end
+
+puts "It is running in the process #{pid}"

data/tests/taemons_test.rb

@@ -0,0 +1,112 @@
+require './tests/test_helper'
+require 'tiny_daemon'
+
+def test_daemon(use_signal) 
+  is_running = true
+  exit_invoked = false
+  exit_gracefully = false
+
+  File.delete('tmp/test_tiny_daemon.log')
+
+  daemon = TinyDaemon.new("test_tiny_daemon", "tmp", "tmp")
+  daemon.stop
+  daemon.exit do
+    is_running = false
+    exit_invoked = true
+  end
+  pid = daemon.start do
+    while is_running
+      puts Time.now.to_i.to_s
+      sleep(0.1)
+    end
+
+    exit_gracefully = true
+  end
+
+  assert(true, File.exists?('tmp/test_tiny_daemon.log'))
+  assert(true, File.exists?('tmp/test_tiny_daemon.pid'))
+
+  sleep(3)
+
+  if use_signal
+    Process.kill("TERM", pid)
+  else
+    daemon.stop
+  end
+
+  assert(true, exit_invoked)
+  assert(true, exit_gracefully)
+end
+
+describe TinyDaemon do
+  it "fork a new process and signals TERM" do
+    test_daemon(true)
+  end
+
+  it "can stop programmatically" do
+    test_daemon(false)
+  end
+
+  it "starts twice with no problem" do
+    is_running = true
+
+    daemon = TinyDaemon.new("test_tiny_daemon", "tmp", "tmp")
+    daemon.stop
+    daemon.exit do
+      is_running = false
+    end
+    pid1 = daemon.start do
+      while is_running
+        puts Time.now.to_i.to_s
+        sleep(0.1)
+      end
+    end
+
+    daemon.stop
+    pid2 = daemon.start do
+      while is_running
+        puts Time.now.to_i.to_s
+        sleep(0.1)
+      end
+    end
+
+    assert_equal(false, pid1 == pid2)
+    assert_raises(Errno::ESRCH) { 
+      Process.kill(0, pid1)
+    }
+    assert_equal(1, Process.kill(0, pid2))
+
+    daemon.stop
+  end
+
+  it "should timeout on start" do
+    daemon = TinyDaemon.new("test_tiny_daemon", "tmp", "tmp")
+    daemon.stop
+
+    assert_raises(RuntimeError) {
+      daemon.start do
+        raise 'exception'
+      end
+    }
+  end
+
+  it "should timeout on stop" do
+    is_running = true
+
+    daemon = TinyDaemon.new("test_tiny_daemon", "tmp", "tmp")
+    daemon.stop
+    daemon.exit do
+      puts "exit invoked"
+    end
+    daemon.start do
+      while is_running
+        puts Time.now.to_i.to_s
+        sleep(0.1)
+      end
+    end
+
+    assert_raises(RuntimeError) { daemon.stop(1) }
+
+    is_running = false
+  end
+end

data/tests/test_helper.rb

@@ -0,0 +1,4 @@
+require 'minitest/autorun'
+require 'minitest/spec'
+
+FileUtils.mkdir_p 'tmp'

data/tests/tiny_daemon/process_file_test.rb

@@ -0,0 +1,40 @@
+require 'fileutils'
+require './tests/test_helper'
+require 'tiny_daemon/process_file'
+
+describe TinyDaemon::ProcessFile do
+  before(:each) do
+    File.delete("tmp/test_app.pid") if File.exists?("tmp/test_app.pid")
+    assert_equal(false, File.exists?("tmp/test_app.pid"))
+  end
+
+  it "uses correct file path" do
+    assert_equal("tmp/test_app.pid", TinyDaemon::ProcessFile.new("test_app", "tmp").pid_file_path)
+  end
+
+  it "deletes pid file" do
+    FileUtils.touch("tmp/test_app.pid")
+    assert_equal(true, File.exists?("tmp/test_app.pid"))
+
+    TinyDaemon::ProcessFile.new("test_app", "tmp").clean
+    assert_equal(false, File.exists?("tmp/test_app.pid"))
+  end
+
+  it "stores and gets" do
+    pf = TinyDaemon::ProcessFile.new("test_app", "tmp")
+    pf.store(1111)
+
+    assert_equal(1111, pf.get)
+  end
+
+  it "doesn't store" do
+    pf = TinyDaemon::ProcessFile.new("test_app", "tmp")
+    pf.store(1111)
+
+    assert_raises(RuntimeError) { 
+      pf.store(1112)
+    }
+
+    assert_equal(1111, pf.get)
+  end
+end

data/tiny_daemon.gemspec

@@ -0,0 +1,20 @@
+require './lib/tiny_daemon/version'
+
+Gem::Specification.new do |s|
+  s.name = "tiny_daemon"
+  s.version = TinyDaemon::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Tanin Na Nakorn"]
+  s.email = ["tanin47@yahoo.com"]
+  s.homepage = "http://github.com/tanin47/tiny_daemon"
+  s.summary = %q{tiny_daemon}
+  s.description = %q{Daemonize a Ruby code}
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {tests}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency("rake")
+  s.add_development_dependency("minitest")
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: tiny_daemon
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Tanin Na Nakorn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Daemonize a Ruby code
+email:
+- tanin47@yahoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/tiny_daemon.rb
+- lib/tiny_daemon/process_file.rb
+- lib/tiny_daemon/version.rb
+- tests/example.rb
+- tests/taemons_test.rb
+- tests/test_helper.rb
+- tests/tiny_daemon/process_file_test.rb
+- tiny_daemon.gemspec
+homepage: http://github.com/tanin47/tiny_daemon
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: tiny_daemon
+test_files: []
+has_rdoc: