daemontools 0.2.8 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '088f99d7ee5b8816c0966f1a3d6f21e9877c27486ae41bd3b8b3673a8f6cb436'
-  data.tar.gz: 3feb328381a172969861003b8cd4a5915eb26725242f1ee14ca9d0617e3582cc
+  metadata.gz: 0406a7ec3beb2cb50e6103fc504b6c245f0051a59404d24832fa10fd3f60af5b
+  data.tar.gz: e850a26c07581ca728958072af3a4649b856286ac7756cc5c080adef0da55343
 SHA512:
-  metadata.gz: 4d8d8f56cf833668fedb16f7bac6d8df99ab0ffd001d0d13487b6859ed029a3ee2394514721bc8e967942f9cfe3d5a0f2acb888438af9216349878d8042e9c43
-  data.tar.gz: 4373911d28e58fe56120bafddcfb159f1df066eb4adcdcbe45f646c207fa991497e9354b1e64e1637eafed176042fc07ba861e3ea492b4727e5805dc08c57552
+  metadata.gz: 3947df53ae94a0f59d23e661ea636c31c45a293ad9c2fae5da51a5c0bb4d3d9c4553f724c3400f1c483a88065d2e735a5e365550b11445b1ffcfa45c8b7f8962
+  data.tar.gz: 1a71473ab9fbde2e778d98133fc99d207782d9ce3409d7494d5713cffddac408b2f66fcb5161e1212fdb9730d5be0e0348e718a6848457091524591ef63868a1

data/lib/daemontools/service.rb

@@ -0,0 +1,194 @@
+module Daemontools
+  class Service
+
+    CACHED_SERVICES = {}
+
+    def self.[](name)
+      CACHED_SERVICES[name] ||= new(name)
+    end
+
+    def initialize(name)
+      @name = name
+      @path = "#{Daemontools.svc_root}/#{name}"
+      @log_path = "#{@path}/log"
+    end
+
+    # Actions
+
+    def add(command, options)
+      apply_options(command: command, **options)
+
+      Dir.exist?(@path) ? stop : Dir.mkdir(@path)
+      Dir.mkdir(@log_path) unless Dir.exist?(@log_path)
+
+      File.open("#{@path}/down", 'w') { |f| f.write('') }
+      File.open("#{@log_path}/down", 'w') { |f| f.write('') }
+      File.open("#{@log_path}/run", 'w', 0o755) { |f| f.write(run_template('log.erb')) }
+      File.open("#{@path}/run", 'w', 0o755) { |f| f.write(run_template('run.erb')) }
+
+      wait_start(options[:wait_timeout]) unless options[:not_wait]
+
+      true
+    end
+
+    def delete(rm_cmd)
+      return false unless check_service_exists(false)
+
+      stop
+      sleep 0.3
+      cmd = rm_cmd.nil? ? "sudo rm -rf #{@path} 2>&1" : "#{rm_cmd} #{@path}"
+      r = `#{cmd}`
+      raise r if $?.exitstatus != 0
+
+      CACHED_SERVICES.delete(@name)
+      true
+    end
+
+    def stop
+      run_svc('d')
+    end
+
+    def start
+      run_svc('u')
+    end
+
+    def restart
+      run_svc('t')
+    end
+
+    # Statuses
+
+    def status
+      check_service_exists
+      r = `sudo svstat #{@path} 2>&1`
+      raise r if $?.exitstatus != 0
+      raise 'Unknown status' unless r.match(/.*?:\s*(\S+).*\s(\d+) seconds.*/)
+
+      [::Regexp.last_match(1), ::Regexp.last_match(2).to_i]
+    end
+
+    def up?
+      status[0] == 'up'
+    end
+
+    def down?
+      status[0] == 'down'
+    end
+
+    def check_service_exists(raise_error = true)
+      exists = Dir.exist?(@path)
+      raise_error && !exists ? raise("Service #{@name} not exists") : exists
+    end
+
+    # Run States
+
+    def run_status
+      check_service_exists
+      File.exist?("#{@path}/down") ? 'down' : 'up'
+    end
+
+    def run_status_up?
+      run_status == 'up'
+    end
+
+    def run_status_down?
+      run_status == 'down'
+    end
+
+    def run_status_up!
+      File.delete("#{@path}/down")
+      File.delete("#{@log_path}/down") if Dir.exist?(@log_path)
+      true
+    end
+
+    def run_status_down!
+      check_service_exists
+      File.open("#{@path}/down", 'w') { |f| f.write('') }
+      File.open("#{@log_path}/down", 'w') { |f| f.write('') } if Dir.exist?(@log_path)
+
+      true
+    end
+
+    # Tmp Actions
+
+    def add_empty
+      Dir.mkdir(@path) unless Dir.exist?(@path)
+      File.open("#{@path}/down", 'w') { |f| f.write('') }
+
+      wait_start(10)
+
+      File.delete("#{@path}/down")
+      stop
+
+      true
+    end
+
+    def add_empty_tmp
+      path = "#{Daemontools.tmp_root}/daemontools_service_#{@name}"
+      Dir.mkdir(path) unless Dir.exist?(path)
+
+      true
+    end
+
+    def move_tmp
+      tmp_path = "#{Daemontools.tmp_root}/daemontools_service_#{@name}"
+      svc_path = @path
+
+      r = `mv #{tmp_path} #{svc_path}`
+      raise r if $?.exitstatus != 0
+      raise r unless r.empty?
+
+      wait_start(10)
+
+      true
+    end
+
+    def tmp_exists?
+      Dir.exist?("#{Daemontools.tmp_root}/daemontools_service_#{@name}")
+    end
+
+    private
+
+    def run_svc(command)
+      check_service_exists
+      r = `sudo svc -#{command} #{@path} 2>&1`
+      raise r if $?.exitstatus != 0
+      raise r unless r.empty?
+
+      return true unless Dir.exist?(@log_path)
+
+      r = `sudo svc -#{command} #{@log_path} 2>&1`
+      raise r if $?.exitstatus != 0
+      raise r unless r.empty?
+
+      true
+    end
+
+    def run_template(template_name)
+      @user = Etc.getpwuid(Process.uid).name
+      template_path = "#{__dir__}/../templates/#{template_name}"
+      ERB.new(File.read(template_path)).result(binding)
+    end
+
+    def apply_options(**options)
+      @command = options[:command]
+      @log_dir = options[:log_dir] || "#{Daemontools.log_root}/#{@name}"
+      @pre_command = options[:pre_command]
+      @sleep = options[:sleep] || 3
+      @change_user_command = options[:change_user_command]
+      @ulimit = options[:ulimit]
+      @write_time = options[:write_time]
+    end
+
+    def wait_start(wait_timeout = nil)
+      wait_timeout ||= 10
+      now = Time.now.to_f
+
+      while `sudo svstat #{@path} 2>&1`.match(/unable to open/i)
+        raise 'Timeout wait for svc add service' if Time.now.to_f - now > wait_timeout
+
+        sleep 0.1
+      end
+    end
+  end
+end

data/lib/daemontools/version.rb

@@ -1,3 +1,3 @@
 module Daemontools
-  VERSION = "0.2.8"
+  VERSION = "0.2.10"
 end

data/lib/daemontools.rb

@@ -1,4 +1,5 @@
 require 'daemontools/version'
+require 'daemontools/service'
 require 'daemontools/service_builder'
 require 'daemontools/service_remover'
 require 'etc'
@@ -12,168 +13,87 @@ module Daemontools
   @log_root = '/var/log/svc'
   @tmp_root = '/tmp'
 
-  def self.exists?(name)
-    check_service_exists(name, false)
-  end
-
-  def self.tmp_exists?(name)
-    Dir.exists?("#{@tmp_root}/daemontools_service_#{name}")
-  end
+  # Actions
 
-  def self.status(name)
-    check_service_exists(name)
-    r = `sudo svstat #{@path} 2>&1`
-    raise r if $?.exitstatus != 0
-    raise "Unknown status" unless r.match(/.*?:\s*(\S+).*\s(\d+) seconds.*/)
-    [$1, $2.to_i]
+  def self.add(name, command, options = {})
+    Service[name].add(command, options)
   end
 
-  def self.up?(name)
-    status(name)[0] == "up"
+  def self.delete(name, rm_cmd = nil)
+    Service[name].delete(rm_cmd)
   end
 
-  def self.down?(name)
-    status(name)[0] == "down"
+  def self.start(name)
+    Service[name].start
   end
 
   def self.stop(name)
-    run_svc(name, 'd')
-  end
-
-  def self.start(name)
-    run_svc(name, 'u')
+    Service[name].stop
   end
 
   def self.restart(name)
-    run_svc(name, 't')
+    Service[name].restart
   end
 
-  def self.add_empty(name)
-    path = "#{@svc_root}/#{name}"
-    Dir.mkdir(path) unless Dir.exists?(path)
-    File.open("#{path}/down", 'w') {|f| f.write('')}
-    now = Time.now.to_f
-    while `sudo svstat #{path} 2>&1`.match(/unable to open/i)
-      raise "Timeout wait for svc add service" if Time.now.to_f - now > 10
-      sleep 0.1
-    end
-    File.delete("#{path}/down")
-    stop(name)
-    true
-  end
+  # Statuses
 
-  def self.add_empty_tmp(name)
-    path = "#{@tmp_root}/daemontools_service_#{name}"
-    Dir.mkdir(path) unless Dir.exists?(path)
-    true
+  def self.status(name)
+    Service[name].status
   end
 
-  def self.move_tmp(name)
-    tmp_path = "#{@tmp_root}/daemontools_service_#{name}"
-    svc_path = "#{@svc_root}/#{name}"
-
-    r = `mv #{tmp_path} #{svc_path}`
-    raise r if $?.exitstatus != 0
-    raise r if ! r.empty?
-
-    now = Time.now.to_f
-    while `sudo svstat #{svc_path} 2>&1`.match(/unable to open/i)
-      raise "Timeout wait for svc add service" if Time.now.to_f - now > 10
-      sleep 0.1
-    end
+  def self.up?(name)
+    Service[name].up?
+  end
 
-    true
+  def self.down?(name)
+    Service[name].down?
   end
 
-  def self.add(name, command, options = {})
-    @name = name
-    @command = command
-    @log_dir = options[:log_dir] || "#{@log_root}/#{@name}"
-    @pre_command = options[:pre_command]
-    @sleep = options[:sleep] || 3
-    @path = "#{@svc_root}/#{name}"
-    @change_user_command = options[:change_user_command]
-    @ulimit = options[:ulimit]
-    @write_time = options[:write_time]
-
-    if Dir.exists?(@path)
-      stop(name)
-    else
-      Dir.mkdir(@path)
-    end
-    File.open("#{@path}/down", 'w') {|f| f.write('')}
-    Dir.mkdir("#{@path}/log") unless Dir.exists?("#{@path}/log")
-    File.open("#{@path}/log/run", 'w', 0755) {|f| f.write(run_template('log.erb'))}
-    File.open("#{@path}/run", 'w', 0755) {|f| f.write(run_template('run.erb'))}
-
-    unless options[:not_wait]
-      wait_timeout = options[:wait_timeout] || 10
-      now = Time.now.to_f
-      while `sudo svstat #{@path} 2>&1`.match(/unable to open/i)
-        raise "Timeout wait for svc add service" if Time.now.to_f - now > wait_timeout
-        sleep 0.1
-      end
-    end
-
-    true
+  def self.exists?(name)
+    Service[name].check_service_exists(false)
   end
 
-  def self.delete(name, rm_cmd = nil)
-    return false unless exists?(name)
-    stop(name)
-    sleep 0.3
-    cmd = rm_cmd.nil? ? "sudo rm -rf #{@path} 2>&1" : "#{rm_cmd} #{@path}"
-    r = `#{cmd}`
-    raise r if $?.exitstatus != 0
-    true
+  def self.check_service_exists(name, raise_error = true)
+    Service[name].check_service_exists(raise_error)
   end
 
+  # Run States
+
   def self.run_status(name)
-    check_service_exists(name)
-    File.exists?("#{@path}/down") ? "down" : "up"
+    Service[name].run_status
   end
 
   def self.run_status_up?(name)
-    run_status(name) == "up"
+    Service[name].run_status_up?
   end
 
   def self.run_status_down?(name)
-    run_status(name) == "down"
+    Service[name].run_status_down?
   end
 
   def self.make_run_status_up(name)
-    File.delete("#{@path}/down")
-    true
+    Service[name].run_status_up!
   end
 
   def self.make_run_status_down(name)
-    check_service_exists(name)
-    File.open("#{@path}/down", 'w') {|f| f.write('')}
-    true
+    Service[name].run_status_down!
   end
 
-  private
+  # Tmp Actions
 
-  def self.check_service_exists(name, raise_error = true)
-    @path = "#{@svc_root}/#{name}"
-    if raise_error
-      raise "Service #{name} not exists" unless Dir.exists?(@path)
-    else
-      Dir.exists?(@path)
-    end
-  end
-
-  def self.run_svc(name, command)
-    check_service_exists(name)
-    r = `sudo svc -#{command} #{@path} 2>&1`
-    raise r if $?.exitstatus != 0
-    raise r if ! r.empty?
-    true
-  end
-
-  def self.run_template(template_name)
-    @user = Etc.getpwuid(Process.uid).name
-    template_path = File.expand_path(File.dirname(__FILE__))+'/../templates/'+template_name
-    ERB.new(File.read(template_path)).result(binding())
+  def self.add_empty(name)
+    Service[name].add_empty
+  end
+
+  def self.add_empty_tmp(name)
+    Service[name].add_empty_tmp
+  end
+
+  def self.move_tmp(name)
+    Service[name].move_tmp
+  end
+
+  def self.tmp_exists?(name)
+    Service[name].tmp_exists?
   end
 end

data/spec/service_spec.rb

@@ -0,0 +1,157 @@
+require 'daemontools'
+
+RSpec.describe Daemontools::Service do
+  let(:svc_root) { '/tmp/svc_root' }
+  let(:tmp_root) { '/tmp/tmp_root' }
+  let(:log_root) { '/tmp/log_root' }
+
+  before do
+    stub_const('Daemontools::Service::CACHED_SERVICES', {})
+
+    allow(Daemontools).to receive(:svc_root).and_return(svc_root)
+    allow(Daemontools).to receive(:tmp_root).and_return(tmp_root)
+    allow(Daemontools).to receive(:log_root).and_return(log_root)
+
+    FileUtils.mkdir_p(svc_root)
+    FileUtils.mkdir_p(tmp_root)
+    FileUtils.mkdir_p(log_root)
+  end
+
+  after do
+    FileUtils.rm_rf(svc_root)
+    FileUtils.rm_rf(tmp_root)
+    FileUtils.rm_rf(log_root)
+  end
+
+  describe '.[]' do
+    it 'caches and returns the same instance for the same name' do
+      s1 = described_class['test']
+      s2 = described_class['test']
+      expect(s1).to be_a(described_class)
+      expect(s1).to equal(s2)
+    end
+  end
+
+  describe '#check_service_exists' do
+    let(:service) { described_class.new('svc1') }
+
+    it 'returns false when the directory does not exist' do
+      expect(service.check_service_exists(false)).to be false
+    end
+
+    it 'raises an error when directory is missing and raise_error=true' do
+      expect { service.check_service_exists(true) }.to raise_error(/not exists/)
+    end
+
+    it 'returns true when the directory exists' do
+      FileUtils.mkdir_p("#{svc_root}/svc1")
+      expect(service.check_service_exists(false)).to be true
+    end
+  end
+
+  describe '#delete' do
+    let(:service) { described_class.new('svc1') }
+
+    before do
+      FileUtils.mkdir_p("#{svc_root}/svc1")
+      allow(service).to receive(:stop).and_return(true)
+      allow(service).to receive(:`).and_return('')
+      allow($?).to receive(:exitstatus).and_return(0)
+      Daemontools::Service::CACHED_SERVICES['svc1'] = service
+    end
+
+    it 'removes the service from cache and returns true' do
+      expect(service.delete(nil)).to be true
+      expect(Daemontools::Service::CACHED_SERVICES).not_to have_key('svc1')
+    end
+
+    it 'returns false when service does not exist' do
+      FileUtils.rm_rf("#{svc_root}/svc1")
+      expect(service.delete(nil)).to be false
+    end
+
+    it 'raises an error when command exit status is non‑zero' do
+      allow($?).to receive(:exitstatus).and_return(1)
+      expect { service.delete(nil) }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe '#status' do
+    let(:service) { described_class.new('svc2') }
+    let(:output)  { 'svc2: up (pid 1234) 5 seconds' }
+
+    before do
+      FileUtils.mkdir_p("#{svc_root}/svc2")
+      allow(service).to receive(:`).and_return(output)
+      allow($?).to receive(:exitstatus).and_return(0)
+    end
+
+    it 'returns [status, seconds] for valid svstat output' do
+      expect(service.status).to eq(%w[up 5].tap { |a| a[1] = 5 })
+    end
+
+    it 'raises "Unknown status" for unexpected output' do
+      allow(service).to receive(:`).and_return('something weird')
+      expect { service.status }.to raise_error('Unknown status')
+    end
+
+    it 'raises an error when command fails' do
+      allow($?).to receive(:exitstatus).and_return(1)
+      expect { service.status }.to raise_error(/svc2/)
+    end
+  end
+
+  describe '#run_status_*' do
+    let(:service) { described_class.new('svc3') }
+
+    before do
+      FileUtils.mkdir_p("#{svc_root}/svc3")
+    end
+
+    it 'returns "up" when no down file exists' do
+      expect(service.run_status).to eq('up')
+    end
+
+    it 'returns "down" when down file exists' do
+      FileUtils.touch("#{svc_root}/svc3/down")
+      expect(service.run_status).to eq('down')
+    end
+
+    it '#run_status_up! removes down files' do
+      FileUtils.mkdir_p("#{svc_root}/svc3/log")
+      FileUtils.touch("#{svc_root}/svc3/down")
+      FileUtils.touch("#{svc_root}/svc3/log/down")
+      service.run_status_up!
+      expect(File).not_to exist("#{svc_root}/svc3/down")
+      expect(File).not_to exist("#{svc_root}/svc3/log/down")
+    end
+
+    it '#run_status_down! creates down files' do
+      FileUtils.mkdir_p("#{svc_root}/svc3/log")
+      service.run_status_down!
+      expect(File).to exist("#{svc_root}/svc3/down")
+      expect(File).to exist("#{svc_root}/svc3/log/down")
+    end
+  end
+
+  describe '#tmp_exists?' do
+    let(:service) { described_class.new('svc_tmp') }
+
+    it 'returns true when temporary directory exists' do
+      FileUtils.mkdir_p("#{tmp_root}/daemontools_service_svc_tmp")
+      expect(service.tmp_exists?).to be true
+    end
+
+    it 'returns false when temporary directory is missing' do
+      FileUtils.rm_rf("#{tmp_root}/daemontools_service_svc_tmp")
+      expect(service.tmp_exists?).to be false
+    end
+  end
+
+  describe '.CACHED_SERVICES' do
+    it 'holds created instances' do
+      s1 = described_class['foo']
+      expect(Daemontools::Service::CACHED_SERVICES['foo']).to eq(s1)
+    end
+  end
+end

data/templates/rvm.erb

@@ -1,3 +1,15 @@
-/bin/bash -l -c '<%= @command.gsub('&&', "\n") %> 2>&1 &
-trap "kill $!" exit INT TERM
-wait'
+/bin/bash -l -c '
+<%= @command.gsub('&&', "\n") %> 2>&1 &
+pid=$!
+pgid=$(ps -o pgid= -p $pid | tr -d " ")
+
+trap "
+  echo \"Sending SIGTERM to main process PID \$pid\"
+  kill -TERM \$pid
+  sleep 0.5
+  echo \"Sending SIGKILL to process group PGID \$pgid\"
+  kill -KILL -\$pgid
+" EXIT INT TERM
+
+wait $pid
+'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: daemontools
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.10
 platform: ruby
 authors:
 - sh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-11-11 00:00:00.000000000 Z
+date: 2026-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,11 +75,13 @@ files:
 - fixtures/stubs/service_remover_stub.rb
 - lib/daemontools.rb
 - lib/daemontools/capistrano.rb
+- lib/daemontools/service.rb
 - lib/daemontools/service_builder.rb
 - lib/daemontools/service_remover.rb
 - lib/daemontools/version.rb
 - spec/builder_spec.rb
 - spec/service_delete_spec.rb
+- spec/service_spec.rb
 - spec/spec_helper.rb
 - templates/log.erb
 - templates/run.erb
@@ -109,4 +111,5 @@ summary: Distributed storage
 test_files:
 - spec/builder_spec.rb
 - spec/service_delete_spec.rb
+- spec/service_spec.rb
 - spec/spec_helper.rb