Class: MultiProcess::Process

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Defined in:
lib/multi_process/process.rb,
lib/multi_process/process/rails.rb,
lib/multi_process/process/bundle_exec.rb

Overview

Describes a single process that can be configured and run.

Process basically is just a thin wrapper around ChildProcess.

Defined Under Namespace

Modules: BundleExec, Rails

Process collapse

Working Directory collapse

Receiver collapse

Process collapse

Environment collapse

Constructor Details

#initialize(*args) ⇒ Process

Returns a new instance of Process.



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/multi_process/process.rb', line 25

def initialize(*args)
  args.flatten!
  opts = (args.last.is_a?(Hash) ? args.pop : {})

  @title        = opts[:title].to_s || args.first.to_s.strip.split(/\s+/, 2)[0]
  @command      = args.map {|arg| (/\A[\s"']+\z/.match?(arg) ? arg.inspect : arg).gsub '"', '\"' }.join(' ')
  @childprocess = create_childprocess(*args)

  @env          = opts[:env] if opts[:env].is_a?(Hash)
  @env_clean    = opts[:clean_env].nil? ? true : !opts[:clean_env].nil?

  self.receiver = opts[:receiver] || MultiProcess::Logger.global

  self.dir      = Dir.pwd
  self.dir      = opts[:dir].to_s if opts[:dir]
end

Instance Attribute Details

#childprocess ⇒ Object (readonly)

ChildProcess object.



23
24
25
 
# File 'lib/multi_process/process.rb', line 23

def childprocess
  @childprocess
end

#command ⇒ Object (readonly)

Command as full string.



20
21
22
 
# File 'lib/multi_process/process.rb', line 20

def command
  @command
end

#dir ⇒ Object

Working directory for child process.



149
150
151
 
# File 'lib/multi_process/process.rb', line 149

def dir
  @dir
end

#receiver ⇒ Object

Current receiver. Defaults to ‘MultiProcess::Logger.global`.



189
190
191
 
# File 'lib/multi_process/process.rb', line 189

def receiver
  @receiver
end

#title ⇒ Object (readonly)

Process title used in e.g. logger



17
18
19
 
# File 'lib/multi_process/process.rb', line 17

def title
  @title
end

Instance Method Details

#available!(opts = {}) ⇒ Object

Wait until process is available. See #available?.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Options.

Options Hash (opts):

  • :timeout (Integer) —

    Timeout in seconds. Will raise Timeout::Error if timeout is reached.



112
113
114
115
116
117
118
119
120
 
# File 'lib/multi_process/process.rb', line 112

def available!(opts = {})
  timeout = opts[:timeout] ? opts[:timeout].to_i : MultiProcess::DEFAULT_TIMEOUT

  Timeout.timeout timeout do
    sleep 0.2 until available?
  end
rescue Timeout::Error
  raise Timeout::Error.new "Server #{id.inspect} on port #{port} didn't get up after #{timeout} seconds..."
end

#available? ⇒ Boolean

Check if server is available. What available means can be defined by subclasses e.g. a server process can check if server port is reachable.

By default is process if available if alive? returns true.

Returns:

  • (Boolean) 


102
103
104
 
# File 'lib/multi_process/process.rb', line 102

def available?
  alive?
end

#clean_env? ⇒ Boolean

Check if environment will be cleaned up for process.

Currently that includes wrapping the process start in ‘Bundler.with_unbundled_env` to remove bundler environment variables.

Returns:

  • (Boolean) 


167
168
169
 
# File 'lib/multi_process/process.rb', line 167

def clean_env?
  !!@env_clean
end

#env ⇒ Object

Return current environment.



173
174
175
 
# File 'lib/multi_process/process.rb', line 173

def env
  @env ||= {}
end

#env=(env) ⇒ Object

Set environment.



179
180
181
182
183
 
# File 'lib/multi_process/process.rb', line 179

def env=(env)
  raise ArgumentError.new 'Environment must be a Hash.' unless env.is_a?(Hash)

  @env = env
end

#run(opts = {}) ⇒ Object

Start process and wait until it’s finished.

Given arguments will be passed to #wait.



132
133
134
135
 
# File 'lib/multi_process/process.rb', line 132

def run(opts = {})
  start
  wait opts
end

#run!(opts = {}) ⇒ Object

Start process and wait until it’s finished.

Given arguments will be passed to #wait!.



141
142
143
144
 
# File 'lib/multi_process/process.rb', line 141

def run!(opts = {})
  start
  wait!(opts)
end

#start ⇒ Object

Start process.

Started processes will be stopped when ruby VM exists by hooking into ‘at_exit`.



80
81
82
83
84
85
86
87
 
# File 'lib/multi_process/process.rb', line 80

def start
  return false if started?

  at_exit { stop }
  receiver&.message(self, :sys, command)
  start_childprocess
  @started = true
end

#started? ⇒ Boolean

Check if process was started.

Returns:

  • (Boolean) 


124
125
126
 
# File 'lib/multi_process/process.rb', line 124

def started?
  !!@started
end

#stop(*args) ⇒ Object

Stop process.

Will call ‘ChildProcess#stop`.



93
94
95
 
# File 'lib/multi_process/process.rb', line 93

def stop(*args)
  childprocess.stop(*args) if started?
end

#wait(opts = {}) ⇒ Object

Wait until process finished.

If no timeout is given it will wait definitely.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Options.

Options Hash (opts):

  • :timeout (Integer) —

    Timeout to wait in seconds.



53
54
55
56
57
58
59
 
# File 'lib/multi_process/process.rb', line 53

def wait(opts = {})
  if opts[:timeout]
    childprocess.wait_for_exit opts[:timeout]
  else
    childprocess.wait
  end
end

#wait!(opts = {}) ⇒ Object

Wait until process finished.

If no timeout is given it will wait definitely.

Parameters:

  • opts (Hash) (defaults to: {}) —

    Options.

Options Hash (opts):

  • :timeout (Integer) —

    Timeout to wait in seconds.

Raises:



68
69
70
71
72
73
 
# File 'lib/multi_process/process.rb', line 68

def wait!(opts = {})
  wait(opts)
  return if exit_code.zero?

  raise ::MultiProcess::ProcessError.new(self, "Process #{pid} exited with code #{exit_code}")
end