Module: ShellHelpers::Sh

Extended by:
Sh
Includes:
CLILogging
Included in:
ShellHelpers, Sh, ShDryRun, ShLog, ShQuiet, ShSilent
Defined in:
lib/shell_helpers/sh.rb

Constant Summary

Constants included from CLILogging

CLILogging::LOG_LEVELS

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from CLILogging

#change_logger, #log_and_do, #logger, setup_toggle_trap

Instance Attribute Details

#default_sh_options ⇒ Object 



152
153
154
155
156
157
158
159
 
# File 'lib/shell_helpers/sh.rb', line 152

def default_sh_options
  @default_sh_options||={log: true, capture: false, on_success: nil, on_error: nil, expected:0, dryrun: false, escape: false,
  log_level_execute_debug: :debug,
  log_level_execute: :info, log_level_error: :error,
  log_level_stderr: :error, log_level_stdout_success: :info,
  log_level_stdout_fail: :warn, detach: false,
  mode: :system}
end

#spawned ⇒ Object 



162
163
164
 
# File 'lib/shell_helpers/sh.rb', line 162

def spawned
  @spawned||=[]
end

Instance Method Details

#change_sh_logger(logger) ⇒ Object

Override the default logger (which is the one provided by CLILogging). You would do this if you want a custom logger or you aren't mixing-in CLILogging.

Note that this method is not called sh_logger= to avoid annoying situations where Ruby thinks you are setting a local variable



322
323
324
 
# File 'lib/shell_helpers/sh.rb', line 322

def change_sh_logger(logger)
  @sh_logger = logger
end

#sh(*command, argv0: nil, **opts) ⇒ Object

callbacks: on_success, on_error yield process_status.success?,stdout,stderr,process_status if block_given? returns success; except in capture mode where it returns success, stdout, stderr, process_status



229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
 
# File 'lib/shell_helpers/sh.rb', line 229

def sh(*command, argv0: nil, **opts)
  defaults=default_sh_options
  curopts=defaults.dup
  defaults.keys.each do |k|
    v=opts.delete(k)
    curopts[k]=v unless v.nil?
  end

  log=curopts[:log]
  command=[[command.first, argv0], *command[1..-1]] if argv0 and command.length > 1 and !curopts[:escape]

  if command.length==1 and command.first.kind_of?(Array) #so that sh(["ls", "-a"]) works
    command=command.first
    command=[[command.first, argv0], *command[1..-1]] if argv0 and !curopts[:escape]
  end
  command_name = curopts[:name] || command_name(command) #this keep the options
  # this should not be needed
  command=command.shelljoin if curopts[:escape]
  if log
    sh_logger.send(curopts[:log_level_execute], SimpleColor.color("Executing '#{command_name}'",:bold))
    p_env, p_args, p_opts= Run.process_command(*command, **opts)
    sh_logger.send(curopts[:log_level_execute_debug], SimpleColor.color("Debug execute: #{[p_env, *p_args, p_opts]}", :bold))
  end

  if !curopts[:dryrun]
    if curopts[:capture] || curopts[:mode]==:capture
      stdout,stderr,status = shrun(*command,**opts,mode: :capture)
    elsif curopts[:detach] || curopts[:mode]==:spawn || curopts[:mode]==:detach
      mode = curopts[:detach] ? :detach : curops[:mode]
      _pid = shrun(*command,**opts, mode: mode)
      status=0; stdout=nil; stderr=nil
    elsif curopts[:mode]==:run
      status, stdout, stderr=shrun(*command,mode: curopts[:mode], **opts)
    else
      mode = curopts[:mode] || :system
      shrun(*command,mode: mode, **opts)
      status=$?; stdout=nil; stderr=nil
    end
  else
    sh_logger.info command.to_s
    status=0; stdout=nil; stderr=nil
  end
  process_status = ProcessStatus.new(status,curopts[:expected])

  sh_logger.send(curopts[:log_level_stderr], SimpleColor.color("stderr output of '#{command_name}':\n",:bold,:red)+stderr) unless stderr.nil? or stderr.strip.length == 0 or !log
  if process_status.success?
    sh_logger.send(curopts[:log_level_stdout_success], SimpleColor.color("stdout output of '#{command_name}':\n",:bold,:green)+stdout) unless stdout.nil? or stdout.strip.length == 0 or !log
    curopts[:on_success].call(stdout,stderr,process_status) unless curopts[:on_success].nil?
    # block.call(stdout,stderr,process_status) unless block.nil?
  else
    sh_logger.send(curopts[:log_level_stdout_fail], SimpleColor.color("stdout output of '#{command_name}':\n",:bold,:yellow)+stdout) unless stdout.nil? or stdout.strip.length == 0 or !log
    sh_logger.send(curopts[:log_level_error], SimpleColor.color("Error running '#{command_name}': #{process_status.status}",:red,:bold)) if log
    curopts[:on_error].call(stdout,stderr,process_status) unless curopts[:on_error].nil?
  end
  yield process_status.success?,stdout,stderr,process_status if block_given?
  if curopts[:capture] || curopts[:mode]==:capture || curopts[:mode]==:run
    return process_status.success?,stdout,stderr,process_status
  else
    return process_status.success?
  end

rescue SystemCallError => ex
  sh_logger.send(curopts[:log_level_error], SimpleColor.color("Error running '#{command_name}': #{ex.message}",:red,:bold)) if log
  if block_given?
    yield 127, nil, nil, nil
  else
    return 127, nil, nil, nil
  end
end

#sh!(*args, failure_msg: nil, **opts, &block) ⇒ Object

Run a command, throwing an exception if the command exited nonzero. Otherwise, behaves exactly like #sh. Raises SH::FailedCommandError if the command exited nonzero. Examples:

    sh!("rsync foo bar")
    # => if command fails, app exits and user sees: "error: Command 'rsync foo bar' exited 12"
    sh!("rsync foo bar", :failure_msg => "Couldn't rsync, check log for details")
    # => if command fails, app exits and user sees: "error: Couldn't rsync, check log for details



308
309
310
311
312
313
314
 
# File 'lib/shell_helpers/sh.rb', line 308

def sh!(*args,failure_msg: nil,**opts, &block)
  on_error=Proc.new do |*blockargs|
    process_status=blockargs.last
    raise FailedCommandError.new(process_status.exitstatus,command_name(args),failure_msg: failure_msg)
  end
  sh(*args,**opts,on_error: on_error,&block)
end

#sh_commands(com, **opts) ⇒ Object

split commands on newlines and run sh on each line



327
328
329
330
331
 
# File 'lib/shell_helpers/sh.rb', line 327

def sh_commands(com, **opts)
  com.each_line do |line|
    sh(line.chomp,**opts)
  end
end

#sh_or_proc(cmd, *args, **opts, &b) ⇒ Object

returns only the success or failure



334
335
336
337
338
339
340
341
342
343
344
345
 
# File 'lib/shell_helpers/sh.rb', line 334

def sh_or_proc(cmd, *args, **opts, &b)
  case cmd
  when Proc
    cmd.call(*args, **opts, &b)
  when Array
    suc, _r=SH.sh(*cmd, *args, **opts, &b)
    suc
  when String
    suc, _r=SH.sh(cmd + " #{args.shelljoin}", **opts, &b)
    suc
  end
end

#shrun(*args, mode: :system, block: nil, **opts) ⇒ Object

callback called by sh to select the exec mode mode: :system,:spawn,:exec,:capture opts: sudo, env



172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
 
# File 'lib/shell_helpers/sh.rb', line 172

def shrun(*args,mode: :system, block: nil, **opts)
  env, args, spawn_opts=Run.process_command(*args, **opts)
  # p env, args, spawn_opts
  case mode
  when :system
    system(env,*args,spawn_opts)
  when :spawn, :detach
    pid=spawn(env,*args,spawn_opts, &block)
    if mode==:detach
      Process.detach(pid) 
    else
      spawned << pid
      if block_given?
        yield pid
        Process.wait(pid)
      else
        pid
      end
    end
  when :exec
    exec(env,*args,spawn_opts, &block)
  when :capture
    Run.run_command(env,*args,spawn_opts, &block)
  when :run
    Run.run(env,*args,spawn_opts, &block)
  else
    raise ShError.new("In shrun, mode #{mode} not understood")
  end
end

#wait_spawned ⇒ Object 



165
166
167
 
# File 'lib/shell_helpers/sh.rb', line 165

def wait_spawned
  spawned.each {|c| Process.waitpid(c)}
end