Class: Pups::ExecCommand

Inherits:
Command show all
Defined in:
lib/pups/exec_command.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Command

#interpolate_params, interpolate_params, run

Constructor Details

#initialize(params, cd = nil) ⇒ ExecCommand

Returns a new instance of ExecCommand.



61
62
63
64
65
66
 
# File 'lib/pups/exec_command.rb', line 61

def initialize(params, cd = nil)
  @commands = []
  @params = params
  @cd = interpolate_params(cd)
  @raise_on_fail = true
end

Instance Attribute Details

#background ⇒ Object

Returns the value of attribute background.



5
6
7
 
# File 'lib/pups/exec_command.rb', line 5

def background
  @background
end

#cd ⇒ Object (readonly)

Returns the value of attribute cd.



4
5
6
 
# File 'lib/pups/exec_command.rb', line 4

def cd
  @cd
end

#commands ⇒ Object (readonly)

Returns the value of attribute commands.



4
5
6
 
# File 'lib/pups/exec_command.rb', line 4

def commands
  @commands
end

#raise_on_fail ⇒ Object

Returns the value of attribute raise_on_fail.



5
6
7
 
# File 'lib/pups/exec_command.rb', line 5

def raise_on_fail
  @raise_on_fail
end

#stdin ⇒ Object

Returns the value of attribute stdin.



5
6
7
 
# File 'lib/pups/exec_command.rb', line 5

def stdin
  @stdin
end

#stop_signal ⇒ Object

Returns the value of attribute stop_signal.



5
6
7
 
# File 'lib/pups/exec_command.rb', line 5

def stop_signal
  @stop_signal
end

Class Method Details

.from_hash(hash, params) ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/pups/exec_command.rb', line 39

def self.from_hash(hash, params)
  cmd = new(params, hash["cd"])

  case c = hash["cmd"]
  when String then cmd.add(c)
  when Array then c.each{|i| cmd.add(i)}
  end

  cmd.background = hash["background"]
  cmd.stop_signal = hash["stop_signal"] || "TERM"
  cmd.raise_on_fail = hash["raise_on_fail"] if hash.key? "raise_on_fail"
  cmd.stdin = interpolate_params(hash["stdin"], params)

  cmd
end

.from_str(str, params) ⇒ Object 



55
56
57
58
59
 
# File 'lib/pups/exec_command.rb', line 55

def self.from_str(str, params)
  cmd = new(params)
  cmd.add(str)
  cmd
end

.terminate_async(opts = {}) ⇒ Object 



7
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
36
37
 
# File 'lib/pups/exec_command.rb', line 7

def self.terminate_async(opts={})

  return unless defined? @@asyncs

  Pups.log.info("Terminating async processes")

  @@asyncs.each do |async|
    Pups.log.info("Sending #{async[:stop_signal]} to #{async[:command]} pid: #{async[:pid]}")
    Process.kill(async[:stop_signal],async[:pid]) rescue nil
  end

  @@asyncs.map do |async|
    Thread.new do
      begin
        Timeout.timeout(opts[:wait] || 10) do
          Process.wait(async[:pid]) rescue nil
        end
      rescue Timeout::Error
        Pups.log.info("#{async[:command]} pid:#{async[:pid]} did not terminate cleanly, forcing termination!")
        begin
          Process.kill("KILL",async[:pid])
          Process.wait(async[:pid])
        rescue Errno::ESRCH
        rescue Errno::ECHILD
        end

      end
    end
  end.each(&:join)

end

Instance Method Details

#add(cmd) ⇒ Object 



68
69
70
 
# File 'lib/pups/exec_command.rb', line 68

def add(cmd)
  @commands << process_params(cmd)
end

#process_params(cmd) ⇒ Object 



119
120
121
122
 
# File 'lib/pups/exec_command.rb', line 119

def process_params(cmd)
  processed = interpolate_params(cmd)
  @cd ? "cd #{cd} && #{processed}" : processed
end

#run ⇒ Object 



72
73
74
75
76
77
78
79
80
81
 
# File 'lib/pups/exec_command.rb', line 72

def run
  commands.each do |command|
    Pups.log.info("> #{command}")
    pid = spawn(command)
    Pups.log.info(@result.readlines.join("\n")) if @result
    pid
  end
rescue
  raise if @raise_on_fail
end

#spawn(command) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/pups/exec_command.rb', line 83

def spawn(command)
  if background
    pid = Process.spawn(command)
    (@@asyncs ||= []) << {pid: pid, command: command, stop_signal: (stop_signal || "TERM")}
    Thread.new do
      begin
        Process.wait(pid)
      rescue Errno::ECHILD
        # already exited so skip
      end
      @@asyncs.delete_if{|async| async[:pid] == pid}
    end
    return pid
  end

  IO.popen(command, "w+") do |f|
    if stdin
      # need a way to get stdout without blocking
      Pups.log.info(stdin)
      f.write stdin
      f.close
    else
      Pups.log.info(f.readlines.join)
    end
  end

  unless $? == 0
    err = Pups::ExecError.new("#{command} failed with return #{$?.inspect}")
    err.exit_code = $?.exitstatus
    raise err
  end

  nil

end