Class: Bwrap::Execution::Execute

Inherits:
Object
  • Object
show all
Includes:
Output
Defined in:
lib/bwrap/execution/execute.rb

Overview

Note:

This is kind of pseudo-internal API. Hopefully there won’t be breaking changes. But please use Bwrap::Execution instead of relying functionality of this class, outside of Execute.prepend_rootcmd.

Methods that performs actual execution logic.

Class Attribute Summary collapse

Class Method Summary collapse

Methods included from Output

debug?, debug_output, error_output, handle_output_options, info_output, quiet?, trace?, trace_output, verb_output, verbose?, warn_output

Class Attribute Details

.dry_run ⇒ Object

Dry run flag from parent Execution module.



22
23
24
 
# File 'lib/bwrap/execution/execute.rb', line 22

def dry_run
  @dry_run
end

.w ⇒ Object (readonly)

Can be used to access pipe where ‘Kernel#spawn` should write its data.



19
20
21
 
# File 'lib/bwrap/execution/execute.rb', line 19

def w
  @w
end

Class Method Details

.clean_variables ⇒ Object

Removes data in class instance variables after execution has completed either successfully or with an error.



96
97
98
99
100
 
# File 'lib/bwrap/execution/execute.rb', line 96

def self.clean_variables
  @w = nil
  @r = nil
  @pipe_w = nil
end

.finish_execution(log:, wait:, direct_output:) ⇒ Object

Note:

It makes sense for caller to just return if wait has been set and not check output.

Returns output from command or nil if execution should stop here.



82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/bwrap/execution/execute.rb', line 82

def self.finish_execution log:, wait:, direct_output:
  @w = @pipe_w if direct_output
  @w.close
  unless wait
    @r.close
    return # With wait == false, execute() stops here.
  end
  output = buffer_exec_output @r, log
  @r.close

  output
end

.format_command(command, rootcmd: nil, config: nil) ⇒ Object 



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/bwrap/execution/execute.rb', line 28

def self.format_command command, rootcmd: nil, config: nil
  # Flatten the command if required, so nils can be converted in more of cases.
  # Flattenization is also done in executions, but they also take in account
  # for example rootcmd, so they probably should be done in addition to this one.
  if command.respond_to? :flatten!
    command.flatten!
  end

  prepare_for_execution command

  if config
    bwrap = Bwrap::Bwrap.new config
    bwrap.build_bwrap_arguments command
  elsif rootcmd
    prepend_rootcmd command, rootcmd: rootcmd
  else
    command
  end
end

.handle_execution_fail(fail:, error:, output:, command:) ⇒ Object

Checks whether execution failed and acts accordingly.

Raises:

  • (exception) 


65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/bwrap/execution/execute.rb', line 65

def self.handle_execution_fail fail:, error:, output:, command:
  return unless fail and !execution_success?

  if error == :show and !output.empty?
    Bwrap::Output.warn_output "Command failed with output:\n“#{output}”"
  end

  exception = Bwrap::Execution::ExecutionFailed.new "Command execution failed",
                                                    command: command,
                                                    output: output

  raise exception, exception.message, caller
end

.open_pipes(direct_output) ⇒ Object

Opens pipes for command output handling.



49
50
51
52
53
54
55
 
# File 'lib/bwrap/execution/execute.rb', line 49

def self.open_pipes direct_output
  @r, @w = IO.pipe
  return unless direct_output

  @pipe_w = @w
  @w = $stdout
end

.prepend_rootcmd(command, rootcmd:) ⇒ Object

Stub to instruct implementation in subclass.

Raises:

  • (NotImplementedError) 


103
104
105
106
 
# File 'lib/bwrap/execution/execute.rb', line 103

def self.prepend_rootcmd command, rootcmd:
  raise NotImplementedError, "If rootcmd execution is necessary, monkey patch Bwrap::Execution::Execute " \
                             "to add “self.prepend_rootcmd(command, rootcmd:)” method."
end

.process_output(output:) ⇒ Object

Converts output to be UTF-8.



58
59
60
61
62
 
# File 'lib/bwrap/execution/execute.rb', line 58

def self.process_output output:
  # read_nonblock() uses read(), which always reads as ASCII-8BIT:
  #   In the case of an integer length, the resulting string is always in ASCII-8BIT encoding.
  output.force_encoding("UTF-8").strip
end