Class: Daemon

Inherits:
Object
  • Object
show all
Defined in:
lib/daemon.rb

Defined Under Namespace

Classes: LockError

Class Method Summary collapse

Class Method Details

.daemonize(pid_file, log_file = nil, sync = true) ⇒ Object 



8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/daemon.rb', line 8

def self.daemonize(pid_file, log_file = nil, sync = true)
	if block_given?
		spawn do |send_ok, send_error|
			log = begin
				# try to lock before we kill stdin/out
				lock(pid_file)

				# close I/O
				disconnect(log_file, sync)
			rescue => error
				send_error.call(error)
			end

			send_ok.call

			yield log
		end # => pid, wait
	else
		# become new process group leader
		fence

		# try to lock before we kill stdin/out
		lock(pid_file)

		# close I/O
		disconnect(log_file, sync) # => log
	end
end

.disconnect(log_file = nil, sync = true) ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/daemon.rb', line 96

def self.disconnect(log_file = nil, sync = true)
	if log_file
		log = File.open(log_file, File::WRONLY | File::CREAT | File::APPEND | File::BINARY)
		log.sync = sync
	else
		# don't raise on STDOUT/STDERR write
		log = File.new('/dev/null', File::WRONLY | File::BINARY)
	end

	# disconnect
	STDIN.close # raise IOError on STDIN.read
	STDOUT.reopen log
	STDERR.reopen log

	# provide log IO
	return log
end

.fence ⇒ Object 



72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/daemon.rb', line 72

def self.fence
	if block_given?
		fork do
			Process.setsid # become new session leader
			# now in child
			yield
		end # => pid
	else
		exit! 0 if fork
		Process.setsid # become new session leader
		# now in child
	end
end

.lock(pid_file) ⇒ Object

Raises:



86
87
88
89
90
91
92
93
94
 
# File 'lib/daemon.rb', line 86

def self.lock(pid_file)
	pf = File.open(pid_file, File::RDWR | File::CREAT)
	raise LockError, pf unless pf.flock(File::LOCK_EX | File::LOCK_NB)
	pf.truncate(0)
	pf.write(Process.pid.to_s + "\n")
	pf.flush

	@pf = pf # keep it open and locked until process exits
end

.spawn ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/daemon.rb', line 37

def self.spawn
	r, w = IO.pipe

	pid = fence do
		r.close

		yield(
			->{
				w.write Marshal.dump(nil) # send OK to parent
				w.close
			},
			->(error){
				w.write Marshal.dump(error) # send error to parent
				w.close
				exit 42
			}
		)
	end
	thr = Process.detach(pid)

	w.close
	data = r.read
	data.empty? and fail 'ok/error handler not called!'

	if error = Marshal.load(data)
		thr.join # wait for child to die
		raise error
	end

	return pid, thr
ensure
	w.close unless w.closed?
	r.close
end