Modul Open3

# File lib/open3.rb, line 775
def capture2(*cmd)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  stdin_data = opts.delete(:stdin_data)
  binmode = opts.delete(:binmode)

  popen2(*cmd, opts) {|i, o, t|
    if binmode
      i.binmode
      o.binmode
    end
    out_reader = Thread.new { o.read }
    if stdin_data
      begin
        if stdin_data.respond_to? :readpartial
          IO.copy_stream(stdin_data, i)
        else
          i.write stdin_data
        end
      rescue Errno::EPIPE
      end
    end
    i.close
    [out_reader.value, t.value]
  }
end

Im Grunde ein Wrapper für Open3.popen3, der

• Einen Kindprozess erstellt, indem Open3.popen3 mit den gegebenen Argumenten aufgerufen wird (mit Ausnahme bestimmter Einträge im Hash options; siehe unten).

• Gibt als String stdout_s die Standardausgabe des Kindprozesses zurück.

• Gibt als status ein Process::Status-Objekt zurück, das den Exit-Status des Kindprozesses darstellt.

Gibt das Array [stdout_s, status] zurück.

stdout_s, status = Open3.capture2('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2326047 exit 0>]

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Im Gegensatz zu Process.spawn wartet diese Methode, bis der Kindprozess beendet ist, bevor sie zurückkehrt. Der Aufrufer muss dies also nicht tun.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env im Aufruf von Open3.popen3; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options im Aufruf von Open3.popen3; siehe Ausführungsoptionen.

Der Hash options wird angegeben; zwei Optionen haben lokale Wirkung in der Methode Open3.capture2

• Wenn der Eintrag options[:stdin_data] existiert, wird der Eintrag entfernt und sein String-Wert an die Standardeingabe des Befehls gesendet.

  Open3.capture2('tee', stdin_data: 'Foo')
  
  # => ["Foo", #<Process::Status: pid 2326087 exit 0>]
  

• Wenn der Eintrag options[:binmode] existiert, wird der Eintrag entfernt und die internen Streams werden in den Binärmodus versetzt.

Das einzelne erforderliche Argument ist eines der folgenden:

• command_line, wenn es ein String ist und wenn es mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder wenn es ein oder mehrere Metazeichen enthält.

• exe_path andernfalls.

Argument command_line

Das Zeichenkettenargument command_line ist eine Befehlszeile, die an eine Shell übergeben wird; sie muss mit einem reservierten Shell-Wort beginnen, mit einem speziellen Built-in beginnen oder Metazeichen enthalten.

Open3.capture2('if true; then echo "Foo"; fi') # Shell reserved word.
# => ["Foo\n", #<Process::Status: pid 2326131 exit 0>]
Open3.capture2('echo')                         # Built-in.
# => ["\n", #<Process::Status: pid 2326139 exit 0>]
Open3.capture2('date > date.tmp')              # Contains meta character.
# => ["", #<Process::Status: pid 2326174 exit 0>]

Die Befehlszeile kann auch Argumente und Optionen für den Befehl enthalten.

Open3.capture2('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2326183 exit 0>]

Argument exe_path

Das Argument exe_path ist eines der folgenden:

• Der Zeichenkettenpfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array mit zwei Elementen, das den Pfad zu einer ausführbaren Datei und die Zeichenkette enthält, die als Name des ausgeführten Prozesses verwendet werden soll.

Beispiel

Open3.capture2('/usr/bin/date')
# => ["Fri Sep 29 01:00:39 PM CDT 2023\n", #<Process::Status: pid 2326222 exit 0>]

Ruby ruft die ausführbare Datei direkt auf, ohne Shell und ohne Shell-Erweiterung.

Open3.capture2('doesnt_exist') # Raises Errno::ENOENT

Wenn ein oder mehrere args angegeben sind, ist jedes ein Argument oder eine Option, die an die ausführbare Datei übergeben werden soll.

Open3.capture2('echo', 'C #')
# => ["C #\n", #<Process::Status: pid 2326267 exit 0>]
Open3.capture2('echo', 'hello', 'world')
# => ["hello world\n", #<Process::Status: pid 2326299 exit 0>]

# File lib/open3.rb, line 902
def capture2e(*cmd)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  stdin_data = opts.delete(:stdin_data)
  binmode = opts.delete(:binmode)

  popen2e(*cmd, opts) {|i, oe, t|
    if binmode
      i.binmode
      oe.binmode
    end
    outerr_reader = Thread.new { oe.read }
    if stdin_data
      begin
        if stdin_data.respond_to? :readpartial
          IO.copy_stream(stdin_data, i)
        else
          i.write stdin_data
        end
      rescue Errno::EPIPE
      end
    end
    i.close
    [outerr_reader.value, t.value]
  }
end

Im Grunde ein Wrapper für Open3.popen3, der

• Einen Kindprozess erstellt, indem Open3.popen3 mit den gegebenen Argumenten aufgerufen wird (mit Ausnahme bestimmter Einträge im Hash options; siehe unten).

• Gibt als String stdout_and_stderr_s die zusammengeführte Standardausgabe und den Standardfehler des Kindprozesses zurück.

• Gibt als status ein Process::Status-Objekt zurück, das den Exit-Status des Kindprozesses darstellt.

Gibt das Array [stdout_and_stderr_s, status] zurück.

stdout_and_stderr_s, status = Open3.capture2e('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2371692 exit 0>]

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Im Gegensatz zu Process.spawn wartet diese Methode, bis der Kindprozess beendet ist, bevor sie zurückkehrt. Der Aufrufer muss dies also nicht tun.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env im Aufruf von Open3.popen3; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options im Aufruf von Open3.popen3; siehe Ausführungsoptionen.

Der Hash options wird angegeben; zwei Optionen haben lokale Wirkung in der Methode Open3.capture2e

• Wenn der Eintrag options[:stdin_data] existiert, wird der Eintrag entfernt und sein String-Wert an die Standardeingabe des Befehls gesendet.

  Open3.capture2e('tee', stdin_data: 'Foo')
  # => ["Foo", #<Process::Status: pid 2371732 exit 0>]
  

• Wenn der Eintrag options[:binmode] existiert, wird der Eintrag entfernt und die internen Streams werden in den Binärmodus versetzt.

Das einzelne erforderliche Argument ist eines der folgenden:

• command_line, wenn es ein String ist und wenn es mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder wenn es ein oder mehrere Metazeichen enthält.

• exe_path andernfalls.

Argument command_line

Das Zeichenkettenargument command_line ist eine Befehlszeile, die an eine Shell übergeben wird; sie muss mit einem reservierten Shell-Wort beginnen, mit einem speziellen Built-in beginnen oder Metazeichen enthalten.

Open3.capture2e('if true; then echo "Foo"; fi') # Shell reserved word.
# => ["Foo\n", #<Process::Status: pid 2371740 exit 0>]
Open3.capture2e('echo')                         # Built-in.
# => ["\n", #<Process::Status: pid 2371774 exit 0>]
Open3.capture2e('date > date.tmp')              # Contains meta character.
# => ["", #<Process::Status: pid 2371812 exit 0>]

Die Befehlszeile kann auch Argumente und Optionen für den Befehl enthalten.

Open3.capture2e('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2326183 exit 0>]

Argument exe_path

Das Argument exe_path ist eines der folgenden:

• Der Zeichenkettenpfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array mit zwei Elementen, das den Pfad zu einer ausführbaren Datei und die Zeichenkette enthält, die als Name des ausgeführten Prozesses verwendet werden soll.

Beispiel

Open3.capture2e('/usr/bin/date')
# => ["Sat Sep 30 09:01:46 AM CDT 2023\n", #<Process::Status: pid 2371820 exit 0>]

Ruby ruft die ausführbare Datei direkt auf, ohne Shell und ohne Shell-Erweiterung.

Open3.capture2e('doesnt_exist') # Raises Errno::ENOENT

Wenn ein oder mehrere args angegeben sind, ist jedes ein Argument oder eine Option, die an die ausführbare Datei übergeben werden soll.

Open3.capture2e('echo', 'C #')
# => ["C #\n", #<Process::Status: pid 2371856 exit 0>]
Open3.capture2e('echo', 'hello', 'world')
# => ["hello world\n", #<Process::Status: pid 2371894 exit 0>]

# File lib/open3.rb, line 648
def capture3(*cmd)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  stdin_data = opts.delete(:stdin_data) || ''
  binmode = opts.delete(:binmode)

  popen3(*cmd, opts) {|i, o, e, t|
    if binmode
      i.binmode
      o.binmode
      e.binmode
    end
    out_reader = Thread.new { o.read }
    err_reader = Thread.new { e.read }
    begin
      if stdin_data.respond_to? :readpartial
        IO.copy_stream(stdin_data, i)
      else
        i.write stdin_data
      end
    rescue Errno::EPIPE
    end
    i.close
    [out_reader.value, err_reader.value, t.value]
  }
end

Im Grunde ein Wrapper für Open3.popen3, der

• Einen Kindprozess erstellt, indem Open3.popen3 mit den gegebenen Argumenten aufgerufen wird (mit Ausnahme bestimmter Einträge im Hash options; siehe unten).

• Gibt als Strings stdout_s und stderr_s die Standardausgabe und den Standardfehler des Kindprozesses zurück.

• Gibt als status ein Process::Status-Objekt zurück, das den Exit-Status des Kindprozesses darstellt.

Gibt das Array [stdout_s, stderr_s, status] zurück.

stdout_s, stderr_s, status = Open3.capture3('echo "Foo"')
# => ["Foo\n", "", #<Process::Status: pid 2281954 exit 0>]

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Im Gegensatz zu Process.spawn wartet diese Methode, bis der Kindprozess beendet ist, bevor sie zurückkehrt. Der Aufrufer muss dies also nicht tun.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env im Aufruf von Open3.popen3; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options im Aufruf von Open3.popen3; siehe Ausführungsoptionen.

Der Hash options wird angegeben; zwei Optionen haben lokale Wirkung in der Methode Open3.capture3

• Wenn der Eintrag options[:stdin_data] existiert, wird der Eintrag entfernt und sein String-Wert an die Standardeingabe des Befehls gesendet.

  Open3.capture3('tee', stdin_data: 'Foo')
  # => ["Foo", "", #<Process::Status: pid 2319575 exit 0>]
  

• Wenn der Eintrag options[:binmode] existiert, wird der Eintrag entfernt und die internen Streams werden in den Binärmodus versetzt.

Das einzelne erforderliche Argument ist eines der folgenden:

• command_line, wenn es ein String ist und wenn es mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder wenn es ein oder mehrere Metazeichen enthält.

• exe_path andernfalls.

Argument command_line

Das Zeichenkettenargument command_line ist eine Befehlszeile, die an eine Shell übergeben wird; sie muss mit einem reservierten Shell-Wort beginnen, mit einem speziellen Built-in beginnen oder Metazeichen enthalten.

Open3.capture3('if true; then echo "Foo"; fi') # Shell reserved word.
# => ["Foo\n", "", #<Process::Status: pid 2282025 exit 0>]
Open3.capture3('echo')                         # Built-in.
# => ["\n", "", #<Process::Status: pid 2282092 exit 0>]
Open3.capture3('date > date.tmp')              # Contains meta character.
# => ["", "", #<Process::Status: pid 2282110 exit 0>]

Die Befehlszeile kann auch Argumente und Optionen für den Befehl enthalten.

Open3.capture3('echo "Foo"')
# => ["Foo\n", "", #<Process::Status: pid 2282092 exit 0>]

Argument exe_path

Das Argument exe_path ist eines der folgenden:

• Der Zeichenkettenpfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array mit zwei Elementen, das den Pfad zu einer ausführbaren Datei und die Zeichenkette enthält, die als Name des ausgeführten Prozesses verwendet werden soll.

Beispiel

Open3.capture3('/usr/bin/date')
# => ["Thu Sep 28 05:03:51 PM CDT 2023\n", "", #<Process::Status: pid 2282300 exit 0>]

Ruby ruft die ausführbare Datei direkt auf, ohne Shell und ohne Shell-Erweiterung.

Open3.capture3('doesnt_exist') # Raises Errno::ENOENT

Wenn ein oder mehrere args angegeben sind, ist jedes ein Argument oder eine Option, die an die ausführbare Datei übergeben werden soll.

Open3.capture3('echo', 'C #')
# => ["C #\n", "", #<Process::Status: pid 2282368 exit 0>]
Open3.capture3('echo', 'hello', 'world')
# => ["hello world\n", "", #<Process::Status: pid 2282372 exit 0>]

# File lib/open3.rb, line 1334
def pipeline(*cmds)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  pipeline_run(cmds, opts, [], []) {|ts|
    ts.map(&:value)
  }
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess für jeden der gegebenen cmds durch Aufruf von Process.spawn.

• Leitet die stdout jedes Kindes an die stdin des nächsten Kindes weiter oder, für das letzte Kind, an die stdout des Aufrufers.

• Wartet auf den Abschluss der Kindprozesse.

• Gibt ein Array von Process::Status-Objekten zurück (eines für jedes Kind).

Beispiel

wait_threads = Open3.pipeline('ls', 'grep R')
# => [#<Process::Status: pid 2139200 exit 0>, #<Process::Status: pid 2139202 exit 0>]

Ausgabe

Rakefile
README.md

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env in jedem Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options in jedem Aufruf von Process.spawn; siehe Ausführungsoptionen.

Jedes verbleibende Argument in cmds ist eines von:

• Ein command_line: ein String, der mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder ein oder mehrere Metazeichen enthält.

• Ein exe_path: der String-Pfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array, das einen command_line oder einen exe_path zusammen mit null oder mehr String-Argumenten für den Befehl enthält.

Siehe Argument command_line oder exe_path.

# File lib/open3.rb, line 1104
def pipeline_r(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  pipeline_run(cmds, opts, [out_w], [out_r], &block)
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess für jeden der gegebenen cmds durch Aufruf von Process.spawn.

• Leitet die stdout jedes Kindes an die stdin des nächsten Kindes weiter oder, für das letzte Kind, an die stdout des Aufrufers.

Die Methode wartet nicht auf den Abschluss der Kindprozesse, daher muss der Aufrufer dies tun.

Ohne Block gibt sie ein 2-Element-Array zurück, das Folgendes enthält:

• Den stdout-Stream des letzten Kindprozesses.

• Ein Array von Wait-Threads für alle Kindprozesse.

Beispiel

last_stdout, wait_threads = Open3.pipeline_r('ls', 'grep R')
# => [#<IO:fd 5>, [#<Process::Waiter:0x000055e8de2f9898 dead>, #<Process::Waiter:0x000055e8de2f94b0 sleep>]]
puts last_stdout.read
wait_threads.each do |wait_thread|
  wait_thread.join
end

Ausgabe

Rakefile
README.md

Mit einem gegebenen Block ruft sie den Block mit dem stdout-Stream des letzten Kindprozesses und einem Array der Wait-Threads auf.

Open3.pipeline_r('ls', 'grep R') do |last_stdout, wait_threads|
  puts last_stdout.read
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

Ausgabe

Rakefile
README.md

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env in jedem Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options in jedem Aufruf von Process.spawn; siehe Ausführungsoptionen.

Jedes verbleibende Argument in cmds ist eines von:

• Ein command_line: ein String, der mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder ein oder mehrere Metazeichen enthält.

• Ein exe_path: der String-Pfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array, das einen command_line oder einen exe_path zusammen mit null oder mehr String-Argumenten für den Befehl enthält.

Siehe Argument command_line oder exe_path.

# File lib/open3.rb, line 1014
def pipeline_rw(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  pipeline_run(cmds, opts, [in_r, out_w], [in_w, out_r], &block)
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess für jeden der gegebenen cmds durch Aufruf von Process.spawn.

• Leitet die stdout jedes Kindes an die stdin des nächsten Kindes weiter, oder, für das erste Kind, von der stdin des Aufrufers, oder, für das letzte Kind, an die stdout des Aufrufers.

Die Methode wartet nicht auf den Abschluss der Kindprozesse, daher muss der Aufrufer dies tun.

Ohne Block gibt sie ein 3-Element-Array zurück, das Folgendes enthält:

• Den stdin-Stream des ersten Kindprozesses.

• Den stdout-Stream des letzten Kindprozesses.

• Ein Array von Wait-Threads für alle Kindprozesse.

Beispiel

first_stdin, last_stdout, wait_threads = Open3.pipeline_rw('sort', 'cat -n')
# => [#<IO:fd 20>, #<IO:fd 21>, [#<Process::Waiter:0x000055e8de29ab40 sleep>, #<Process::Waiter:0x000055e8de29a690 sleep>]]
first_stdin.puts("foo\nbar\nbaz")
first_stdin.close # Send EOF to sort.
puts last_stdout.read
wait_threads.each do |wait_thread|
  wait_thread.join
end

Ausgabe

1 bar
2 baz
3 foo

Mit einem gegebenen Block ruft sie den Block mit dem stdin-Stream des ersten Kindes, dem stdout-Stream des letzten Kindes und einem Array der Wait-Threads auf.

Open3.pipeline_rw('sort', 'cat -n') do |first_stdin, last_stdout, wait_threads|
  first_stdin.puts "foo\nbar\nbaz"
  first_stdin.close # send EOF to sort.
  puts last_stdout.read
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

Ausgabe

1 bar
2 baz
3 foo

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env in jedem Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options in jedem Aufruf von Process.spawn; siehe Ausführungsoptionen.

Jedes verbleibende Argument in cmds ist eines von:

• Ein command_line: ein String, der mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder ein oder mehrere Metazeichen enthält.

• Ein exe_path: der String-Pfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array, das einen command_line oder einen exe_path zusammen mit null oder mehr String-Argumenten für den Befehl enthält.

Siehe Argument command_line oder exe_path.

# File lib/open3.rb, line 1272
def pipeline_start(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  if block
    pipeline_run(cmds, opts, [], [], &block)
  else
    ts, = pipeline_run(cmds, opts, [], [])
    ts
  end
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess für jeden der gegebenen cmds durch Aufruf von Process.spawn.

• Wartet nicht auf den Abschluss der Kindprozesse.

Ohne Block gibt sie ein Array der Wait-Threads für alle Kindprozesse zurück.

Beispiel

wait_threads = Open3.pipeline_start('ls', 'grep R')
# => [#<Process::Waiter:0x000055e8de9d2bb0 run>, #<Process::Waiter:0x000055e8de9d2890 run>]
wait_threads.each do |wait_thread|
  wait_thread.join
end

Ausgabe

Rakefile
README.md

Mit einem gegebenen Block ruft sie den Block mit einem Array der Wait-Threads auf.

Open3.pipeline_start('ls', 'grep R') do |wait_threads|
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

Ausgabe

Rakefile
README.md

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env in jedem Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options in jedem Aufruf von Process.spawn; siehe Ausführungsoptionen.

Jedes verbleibende Argument in cmds ist eines von:

• Ein command_line: ein String, der mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder ein oder mehrere Metazeichen enthält.

• Ein exe_path: der String-Pfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array, das einen command_line oder einen exe_path zusammen mit null oder mehr String-Argumenten für den Befehl enthält.

Siehe Argument command_line oder exe_path.

# File lib/open3.rb, line 1195
def pipeline_w(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  pipeline_run(cmds, opts, [in_r], [in_w], &block)
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess für jeden der gegebenen cmds durch Aufruf von Process.spawn.

• Leitet die stdout jedes Kindes an die stdin des nächsten Kindes weiter, oder, für das erste Kind, leitet die stdout des Aufrufers an die stdin des Kindes weiter.

Die Methode wartet nicht auf den Abschluss der Kindprozesse, daher muss der Aufrufer dies tun.

Ohne Block gibt sie ein 2-Element-Array zurück, das Folgendes enthält:

• Den stdin-Stream des ersten Kindprozesses.

• Ein Array von Wait-Threads für alle Kindprozesse.

Beispiel

first_stdin, wait_threads = Open3.pipeline_w('sort', 'cat -n')
# => [#<IO:fd 7>, [#<Process::Waiter:0x000055e8de928278 run>, #<Process::Waiter:0x000055e8de923e80 run>]]
first_stdin.puts("foo\nbar\nbaz")
first_stdin.close # Send EOF to sort.
wait_threads.each do |wait_thread|
  wait_thread.join
end

Ausgabe

1 bar
2 baz
3 foo

Mit einem gegebenen Block ruft sie den Block mit dem stdin-Stream des ersten Kindprozesses und einem Array der Wait-Threads auf.

Open3.pipeline_w('sort', 'cat -n') do |first_stdin, wait_threads|
  first_stdin.puts("foo\nbar\nbaz")
  first_stdin.close # Send EOF to sort.
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

Ausgabe

1 bar
2 baz
3 foo

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env in jedem Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options in jedem Aufruf von Process.spawn; siehe Ausführungsoptionen.

Jedes verbleibende Argument in cmds ist eines von:

• Ein command_line: ein String, der mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder ein oder mehrere Metazeichen enthält.

• Ein exe_path: der String-Pfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array, das einen command_line oder einen exe_path zusammen mit null oder mehr String-Argumenten für den Befehl enthält.

Siehe Argument command_line oder exe_path.

# File lib/open3.rb, line 365
def popen2(*cmd, &block)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  popen_run(cmd, opts, [in_r, out_w], [in_w, out_r], &block)
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess durch Aufruf von Process.spawn mit den gegebenen Argumenten.

• Erstellt die Streams stdin und stdout, die die Standardeingabe und die Standardausgabe im Kindprozess sind.

• Erstellt den Thread wait_thread, der auf den Abschluss des Kindprozesses wartet; der Thread hat die Methode pid, die die Prozess-ID des Kindprozesses zurückgibt.

Ohne Block gibt sie das Array [stdin, stdout, wait_thread] zurück. Der Aufrufer sollte jeden der beiden zurückgegebenen Streams schließen.

stdin, stdout, wait_thread = Open3.popen2('echo')
# => [#<IO:fd 6>, #<IO:fd 7>, #<Process::Waiter:0x00007f58d52dbe98 run>]
stdin.close
stdout.close
wait_thread.pid   # => 2263572
wait_thread.value # => #<Process::Status: pid 2263572 exit 0>

Mit einem gegebenen Block ruft sie den Block mit den drei Variablen (zwei Streams und dem Wait-Thread) auf und gibt den Rückgabewert des Blocks zurück. Der Aufrufer muss die Streams nicht schließen.

Open3.popen2('echo') do |stdin, stdout, wait_thread|
  p stdin
  p stdout
  p wait_thread
  p wait_thread.pid
  p wait_thread.value
end

Ausgabe

#<IO:fd 6>
#<IO:fd 7>
#<Process::Waiter:0x00007f58d59a34b0 sleep>
2263636
#<Process::Status: pid 2263636 exit 0>

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Im Gegensatz zu Process.spawn wartet diese Methode, bis der Kindprozess beendet ist, bevor sie zurückkehrt. Der Aufrufer muss dies also nicht tun.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env im Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options im Aufruf von Process.spawn; siehe Ausführungsoptionen.

Das einzelne erforderliche Argument ist eines der folgenden:

• command_line, wenn es ein String ist und wenn es mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder wenn es ein oder mehrere Metazeichen enthält.

• exe_path andernfalls.

Argument command_line

Das Zeichenkettenargument command_line ist eine Befehlszeile, die an eine Shell übergeben wird; sie muss mit einem reservierten Shell-Wort beginnen, mit einem speziellen Built-in beginnen oder Metazeichen enthalten.

Open3.popen2('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word.
Open3.popen2('echo') {|*args| p args }                         # Built-in.
Open3.popen2('date > date.tmp') {|*args| p args }              # Contains meta character.

Ausgabe (ähnlich für jeden obigen Aufruf)

# => [#<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f7577dfe410 dead>]

Die Befehlszeile kann auch Argumente und Optionen für den Befehl enthalten.

Open3.popen2('echo "Foo"') { |i, o, t| o.gets }
"Foo\n"

Argument exe_path

Das Argument exe_path ist eines der folgenden:

• Der Zeichenkettenpfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array mit zwei Elementen, das den Pfad zu einer ausführbaren Datei und die Zeichenkette enthält, die als Name des ausgeführten Prozesses verwendet werden soll.

Beispiel

Open3.popen2('/usr/bin/date') { |i, o, t| o.gets }
# => "Thu Sep 28 09:41:06 AM CDT 2023\n"

Ruby ruft die ausführbare Datei direkt auf, ohne Shell und ohne Shell-Erweiterung.

Open3.popen2('doesnt_exist') { |i, o, t| o.gets } # Raises Errno::ENOENT

Wenn ein oder mehrere args angegeben sind, ist jedes ein Argument oder eine Option, die an die ausführbare Datei übergeben werden soll.

Open3.popen2('echo', 'C #') { |i, o, t| o.gets }
# => "C #\n"
Open3.popen2('echo', 'hello', 'world') { |i, o, t| o.gets }
# => "hello world\n"

Verwandt

• Open3.popen2e: Macht die Standardeingabe und die zusammengeführte Standardausgabe und den Standardfehler des Kindprozesses als separate Streams verfügbar.

• Open3.popen3: Macht die Standardeingabe-, Standardausgabe- und Standardfehlerstreams des Kindprozesses als separate Streams verfügbar.

# File lib/open3.rb, line 508
def popen2e(*cmd, &block)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[[:out, :err]] = out_w

  popen_run(cmd, opts, [in_r, out_w], [in_w, out_r], &block)
ensure
  if block
    in_r.close
    in_w.close
    out_r.close
    out_w.close
  end
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess durch Aufruf von Process.spawn mit den gegebenen Argumenten.

• Erstellt die Streams stdin, stdout_and_stderr, die die Standardeingabe und die zusammengeführte Standardausgabe und den Standardfehler im Kindprozess sind.

• Erstellt den Thread wait_thread, der auf den Abschluss des Kindprozesses wartet; der Thread hat die Methode pid, die die Prozess-ID des Kindprozesses zurückgibt.

Ohne Block gibt sie das Array [stdin, stdout_and_stderr, wait_thread] zurück. Der Aufrufer sollte jeden der beiden zurückgegebenen Streams schließen.

stdin, stdout_and_stderr, wait_thread = Open3.popen2e('echo')
# => [#<IO:fd 6>, #<IO:fd 7>, #<Process::Waiter:0x00007f7577da4398 run>]
stdin.close
stdout_and_stderr.close
wait_thread.pid   # => 2274600
wait_thread.value # => #<Process::Status: pid 2274600 exit 0>

Mit einem gegebenen Block ruft sie den Block mit den drei Variablen (zwei Streams und dem Wait-Thread) auf und gibt den Rückgabewert des Blocks zurück. Der Aufrufer muss die Streams nicht schließen.

Open3.popen2e('echo') do |stdin, stdout_and_stderr, wait_thread|
  p stdin
  p stdout_and_stderr
  p wait_thread
  p wait_thread.pid
  p wait_thread.value
end

Ausgabe

#<IO:fd 6>
#<IO:fd 7>
#<Process::Waiter:0x00007f75777578c8 sleep>
2274763
#<Process::Status: pid 2274763 exit 0>

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Im Gegensatz zu Process.spawn wartet diese Methode, bis der Kindprozess beendet ist, bevor sie zurückkehrt. Der Aufrufer muss dies also nicht tun.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env im Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options im Aufruf von Process.spawn; siehe Ausführungsoptionen.

Das einzelne erforderliche Argument ist eines der folgenden:

• command_line, wenn es ein String ist und wenn es mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder wenn es ein oder mehrere Metazeichen enthält.

• exe_path andernfalls.

Argument command_line

Das Zeichenkettenargument command_line ist eine Befehlszeile, die an eine Shell übergeben wird; sie muss mit einem reservierten Shell-Wort beginnen, mit einem speziellen Built-in beginnen oder Metazeichen enthalten.

Open3.popen2e('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word.
Open3.popen2e('echo') {|*args| p args }                         # Built-in.
Open3.popen2e('date > date.tmp') {|*args| p args }              # Contains meta character.

Ausgabe (ähnlich für jeden obigen Aufruf)

# => [#<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f7577d8a1f0 dead>]

Die Befehlszeile kann auch Argumente und Optionen für den Befehl enthalten.

Open3.popen2e('echo "Foo"') { |i, o_and_e, t| o_and_e.gets }
"Foo\n"

Argument exe_path

Das Argument exe_path ist eines der folgenden:

• Der Zeichenkettenpfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array mit zwei Elementen, das den Pfad zu einer ausführbaren Datei und die Zeichenkette enthält, die als Name des ausgeführten Prozesses verwendet werden soll.

Beispiel

Open3.popen2e('/usr/bin/date') { |i, o_and_e, t| o_and_e.gets }
# => "Thu Sep 28 01:58:45 PM CDT 2023\n"

Ruby ruft die ausführbare Datei direkt auf, ohne Shell und ohne Shell-Erweiterung.

Open3.popen2e('doesnt_exist') { |i, o_and_e, t| o_and_e.gets } # Raises Errno::ENOENT

Wenn ein oder mehrere args angegeben sind, ist jedes ein Argument oder eine Option, die an die ausführbare Datei übergeben werden soll.

Open3.popen2e('echo', 'C #') { |i, o_and_e, t| o_and_e.gets }
# => "C #\n"
Open3.popen2e('echo', 'hello', 'world') { |i, o_and_e, t| o_and_e.gets }
# => "hello world\n"

Verwandt

• Open3.popen2: Macht die Standardeingabe- und Standardausgabestreams des Kindprozesses als separate Streams verfügbar, ohne Zugriff auf den Standardfehlerstream.

• Open3.popen3: Macht die Standardeingabe-, Standardausgabe- und Standardfehlerstreams des Kindprozesses als separate Streams verfügbar.

# File lib/open3.rb, line 218
def popen3(*cmd, &block)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  err_r, err_w = IO.pipe
  opts[:err] = err_w

  popen_run(cmd, opts, [in_r, out_w, err_w], [in_w, out_r, err_r], &block)
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess durch Aufruf von Process.spawn mit den gegebenen Argumenten.

• Erstellt die Streams stdin, stdout und stderr, die die Standardeingabe, die Standardausgabe und den Standardfehler im Kindprozess sind.

• Erstellt den Thread wait_thread, der auf den Abschluss des Kindprozesses wartet; der Thread hat die Methode pid, die die Prozess-ID des Kindprozesses zurückgibt.

Ohne Block gibt sie das Array [stdin, stdout, stderr, wait_thread] zurück. Der Aufrufer sollte jeden der drei zurückgegebenen Streams schließen.

stdin, stdout, stderr, wait_thread = Open3.popen3('echo')
# => [#<IO:fd 8>, #<IO:fd 10>, #<IO:fd 12>, #<Process::Waiter:0x00007f58d5428f58 run>]
stdin.close
stdout.close
stderr.close
wait_thread.pid   # => 2210481
wait_thread.value # => #<Process::Status: pid 2210481 exit 0>

Mit einem gegebenen Block ruft sie den Block mit den vier Variablen (drei Streams und dem Wait-Thread) auf und gibt den Rückgabewert des Blocks zurück. Der Aufrufer muss die Streams nicht schließen.

Open3.popen3('echo') do |stdin, stdout, stderr, wait_thread|
  p stdin
  p stdout
  p stderr
  p wait_thread
  p wait_thread.pid
  p wait_thread.value
end

Ausgabe

#<IO:fd 6>
#<IO:fd 7>
#<IO:fd 9>
#<Process::Waiter:0x00007f58d53606e8 sleep>
2211047
#<Process::Status: pid 2211047 exit 0>

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Im Gegensatz zu Process.spawn wartet diese Methode, bis der Kindprozess beendet ist, bevor sie zurückkehrt. Der Aufrufer muss dies also nicht tun.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env im Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options im Aufruf von Process.spawn; siehe Ausführungsoptionen.

Das einzelne erforderliche Argument ist eines der folgenden:

• command_line, wenn es ein String ist und wenn es mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder wenn es ein oder mehrere Metazeichen enthält.

• exe_path andernfalls.

Argument command_line

Das Zeichenkettenargument command_line ist eine Befehlszeile, die an eine Shell übergeben wird; sie muss mit einem reservierten Shell-Wort beginnen, mit einem speziellen Built-in beginnen oder Metazeichen enthalten.

Open3.popen3('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word.
Open3.popen3('echo') {|*args| p args }                         # Built-in.
Open3.popen3('date > date.tmp') {|*args| p args }              # Contains meta character.

Ausgabe (ähnlich für jeden obigen Aufruf)

[#<IO:(closed)>, #<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f58d52f28c8 dead>]

Die Befehlszeile kann auch Argumente und Optionen für den Befehl enthalten.

Open3.popen3('echo "Foo"') { |i, o, e, t| o.gets }
"Foo\n"

Argument exe_path

Das Argument exe_path ist eines der folgenden:

• Der Zeichenkettenpfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array mit zwei Elementen, das den Pfad zu einer ausführbaren Datei und die Zeichenkette enthält, die als Name des ausgeführten Prozesses verwendet werden soll.

Beispiel

Open3.popen3('/usr/bin/date') { |i, o, e, t| o.gets }
# => "Wed Sep 27 02:56:44 PM CDT 2023\n"

Ruby ruft die ausführbare Datei direkt auf, ohne Shell und ohne Shell-Erweiterung.

Open3.popen3('doesnt_exist') { |i, o, e, t| o.gets } # Raises Errno::ENOENT

Wenn ein oder mehrere args angegeben sind, ist jedes ein Argument oder eine Option, die an die ausführbare Datei übergeben werden soll.

Open3.popen3('echo', 'C #') { |i, o, e, t| o.gets }
# => "C #\n"
Open3.popen3('echo', 'hello', 'world') { |i, o, e, t| o.gets }
# => "hello world\n"

Achten Sie darauf, Deadlocks zu vermeiden. Die Ausgabestreams stdout und stderr haben Puffer fester Größe. Daher kann das ausgiebige Lesen aus einem, aber nicht aus dem anderen zu einem Deadlock führen, wenn der nicht gelesene Puffer voll ist. Um dies zu vermeiden, sollten stdout und stderr gleichzeitig gelesen werden (mittels Threads oder IO.select).

Verwandt

• Open3.popen2: Macht die Standardeingabe- und Standardausgabestreams des Kindprozesses als separate Streams verfügbar, ohne Zugriff auf den Standardfehlerstream.

• Open3.popen2e: Macht die Standardeingabe und die zusammengeführte Standardausgabe und den Standardfehler des Kindprozesses als separate Streams verfügbar.

# File lib/open3.rb, line 775
def capture2(*cmd)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  stdin_data = opts.delete(:stdin_data)
  binmode = opts.delete(:binmode)

  popen2(*cmd, opts) {|i, o, t|
    if binmode
      i.binmode
      o.binmode
    end
    out_reader = Thread.new { o.read }
    if stdin_data
      begin
        if stdin_data.respond_to? :readpartial
          IO.copy_stream(stdin_data, i)
        else
          i.write stdin_data
        end
      rescue Errno::EPIPE
      end
    end
    i.close
    [out_reader.value, t.value]
  }
end

Im Grunde ein Wrapper für Open3.popen3, der

• Einen Kindprozess erstellt, indem Open3.popen3 mit den gegebenen Argumenten aufgerufen wird (mit Ausnahme bestimmter Einträge im Hash options; siehe unten).

• Gibt als String stdout_s die Standardausgabe des Kindprozesses zurück.

• Gibt als status ein Process::Status-Objekt zurück, das den Exit-Status des Kindprozesses darstellt.

Gibt das Array [stdout_s, status] zurück.

stdout_s, status = Open3.capture2('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2326047 exit 0>]

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Im Gegensatz zu Process.spawn wartet diese Methode, bis der Kindprozess beendet ist, bevor sie zurückkehrt. Der Aufrufer muss dies also nicht tun.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env im Aufruf von Open3.popen3; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options im Aufruf von Open3.popen3; siehe Ausführungsoptionen.

Der Hash options wird angegeben; zwei Optionen haben lokale Wirkung in der Methode Open3.capture2

• Wenn der Eintrag options[:stdin_data] existiert, wird der Eintrag entfernt und sein String-Wert an die Standardeingabe des Befehls gesendet.

  Open3.capture2('tee', stdin_data: 'Foo')
  
  # => ["Foo", #<Process::Status: pid 2326087 exit 0>]
  

• Wenn der Eintrag options[:binmode] existiert, wird der Eintrag entfernt und die internen Streams werden in den Binärmodus versetzt.

Das einzelne erforderliche Argument ist eines der folgenden:

• command_line, wenn es ein String ist und wenn es mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder wenn es ein oder mehrere Metazeichen enthält.

• exe_path andernfalls.

Argument command_line

Das Zeichenkettenargument command_line ist eine Befehlszeile, die an eine Shell übergeben wird; sie muss mit einem reservierten Shell-Wort beginnen, mit einem speziellen Built-in beginnen oder Metazeichen enthalten.

Open3.capture2('if true; then echo "Foo"; fi') # Shell reserved word.
# => ["Foo\n", #<Process::Status: pid 2326131 exit 0>]
Open3.capture2('echo')                         # Built-in.
# => ["\n", #<Process::Status: pid 2326139 exit 0>]
Open3.capture2('date > date.tmp')              # Contains meta character.
# => ["", #<Process::Status: pid 2326174 exit 0>]

Die Befehlszeile kann auch Argumente und Optionen für den Befehl enthalten.

Open3.capture2('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2326183 exit 0>]

Argument exe_path

Das Argument exe_path ist eines der folgenden:

• Der Zeichenkettenpfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array mit zwei Elementen, das den Pfad zu einer ausführbaren Datei und die Zeichenkette enthält, die als Name des ausgeführten Prozesses verwendet werden soll.

Beispiel

Open3.capture2('/usr/bin/date')
# => ["Fri Sep 29 01:00:39 PM CDT 2023\n", #<Process::Status: pid 2326222 exit 0>]

Ruby ruft die ausführbare Datei direkt auf, ohne Shell und ohne Shell-Erweiterung.

Open3.capture2('doesnt_exist') # Raises Errno::ENOENT

Wenn ein oder mehrere args angegeben sind, ist jedes ein Argument oder eine Option, die an die ausführbare Datei übergeben werden soll.

Open3.capture2('echo', 'C #')
# => ["C #\n", #<Process::Status: pid 2326267 exit 0>]
Open3.capture2('echo', 'hello', 'world')
# => ["hello world\n", #<Process::Status: pid 2326299 exit 0>]

# File lib/open3.rb, line 902
def capture2e(*cmd)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  stdin_data = opts.delete(:stdin_data)
  binmode = opts.delete(:binmode)

  popen2e(*cmd, opts) {|i, oe, t|
    if binmode
      i.binmode
      oe.binmode
    end
    outerr_reader = Thread.new { oe.read }
    if stdin_data
      begin
        if stdin_data.respond_to? :readpartial
          IO.copy_stream(stdin_data, i)
        else
          i.write stdin_data
        end
      rescue Errno::EPIPE
      end
    end
    i.close
    [outerr_reader.value, t.value]
  }
end

Im Grunde ein Wrapper für Open3.popen3, der

• Einen Kindprozess erstellt, indem Open3.popen3 mit den gegebenen Argumenten aufgerufen wird (mit Ausnahme bestimmter Einträge im Hash options; siehe unten).

• Gibt als String stdout_and_stderr_s die zusammengeführte Standardausgabe und den Standardfehler des Kindprozesses zurück.

• Gibt als status ein Process::Status-Objekt zurück, das den Exit-Status des Kindprozesses darstellt.

Gibt das Array [stdout_and_stderr_s, status] zurück.

stdout_and_stderr_s, status = Open3.capture2e('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2371692 exit 0>]

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Im Gegensatz zu Process.spawn wartet diese Methode, bis der Kindprozess beendet ist, bevor sie zurückkehrt. Der Aufrufer muss dies also nicht tun.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env im Aufruf von Open3.popen3; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options im Aufruf von Open3.popen3; siehe Ausführungsoptionen.

Der Hash options wird angegeben; zwei Optionen haben lokale Wirkung in der Methode Open3.capture2e

• Wenn der Eintrag options[:stdin_data] existiert, wird der Eintrag entfernt und sein String-Wert an die Standardeingabe des Befehls gesendet.

  Open3.capture2e('tee', stdin_data: 'Foo')
  # => ["Foo", #<Process::Status: pid 2371732 exit 0>]
  

• Wenn der Eintrag options[:binmode] existiert, wird der Eintrag entfernt und die internen Streams werden in den Binärmodus versetzt.

Das einzelne erforderliche Argument ist eines der folgenden:

• command_line, wenn es ein String ist und wenn es mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder wenn es ein oder mehrere Metazeichen enthält.

• exe_path andernfalls.

Argument command_line

Das Zeichenkettenargument command_line ist eine Befehlszeile, die an eine Shell übergeben wird; sie muss mit einem reservierten Shell-Wort beginnen, mit einem speziellen Built-in beginnen oder Metazeichen enthalten.

Open3.capture2e('if true; then echo "Foo"; fi') # Shell reserved word.
# => ["Foo\n", #<Process::Status: pid 2371740 exit 0>]
Open3.capture2e('echo')                         # Built-in.
# => ["\n", #<Process::Status: pid 2371774 exit 0>]
Open3.capture2e('date > date.tmp')              # Contains meta character.
# => ["", #<Process::Status: pid 2371812 exit 0>]

Die Befehlszeile kann auch Argumente und Optionen für den Befehl enthalten.

Open3.capture2e('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2326183 exit 0>]

Argument exe_path

Das Argument exe_path ist eines der folgenden:

• Der Zeichenkettenpfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array mit zwei Elementen, das den Pfad zu einer ausführbaren Datei und die Zeichenkette enthält, die als Name des ausgeführten Prozesses verwendet werden soll.

Beispiel

Open3.capture2e('/usr/bin/date')
# => ["Sat Sep 30 09:01:46 AM CDT 2023\n", #<Process::Status: pid 2371820 exit 0>]

Ruby ruft die ausführbare Datei direkt auf, ohne Shell und ohne Shell-Erweiterung.

Open3.capture2e('doesnt_exist') # Raises Errno::ENOENT

Wenn ein oder mehrere args angegeben sind, ist jedes ein Argument oder eine Option, die an die ausführbare Datei übergeben werden soll.

Open3.capture2e('echo', 'C #')
# => ["C #\n", #<Process::Status: pid 2371856 exit 0>]
Open3.capture2e('echo', 'hello', 'world')
# => ["hello world\n", #<Process::Status: pid 2371894 exit 0>]

# File lib/open3.rb, line 648
def capture3(*cmd)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  stdin_data = opts.delete(:stdin_data) || ''
  binmode = opts.delete(:binmode)

  popen3(*cmd, opts) {|i, o, e, t|
    if binmode
      i.binmode
      o.binmode
      e.binmode
    end
    out_reader = Thread.new { o.read }
    err_reader = Thread.new { e.read }
    begin
      if stdin_data.respond_to? :readpartial
        IO.copy_stream(stdin_data, i)
      else
        i.write stdin_data
      end
    rescue Errno::EPIPE
    end
    i.close
    [out_reader.value, err_reader.value, t.value]
  }
end

Im Grunde ein Wrapper für Open3.popen3, der

• Einen Kindprozess erstellt, indem Open3.popen3 mit den gegebenen Argumenten aufgerufen wird (mit Ausnahme bestimmter Einträge im Hash options; siehe unten).

• Gibt als Strings stdout_s und stderr_s die Standardausgabe und den Standardfehler des Kindprozesses zurück.

• Gibt als status ein Process::Status-Objekt zurück, das den Exit-Status des Kindprozesses darstellt.

Gibt das Array [stdout_s, stderr_s, status] zurück.

stdout_s, stderr_s, status = Open3.capture3('echo "Foo"')
# => ["Foo\n", "", #<Process::Status: pid 2281954 exit 0>]

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Im Gegensatz zu Process.spawn wartet diese Methode, bis der Kindprozess beendet ist, bevor sie zurückkehrt. Der Aufrufer muss dies also nicht tun.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env im Aufruf von Open3.popen3; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options im Aufruf von Open3.popen3; siehe Ausführungsoptionen.

Der Hash options wird angegeben; zwei Optionen haben lokale Wirkung in der Methode Open3.capture3

• Wenn der Eintrag options[:stdin_data] existiert, wird der Eintrag entfernt und sein String-Wert an die Standardeingabe des Befehls gesendet.

  Open3.capture3('tee', stdin_data: 'Foo')
  # => ["Foo", "", #<Process::Status: pid 2319575 exit 0>]
  

• Wenn der Eintrag options[:binmode] existiert, wird der Eintrag entfernt und die internen Streams werden in den Binärmodus versetzt.

Das einzelne erforderliche Argument ist eines der folgenden:

• command_line, wenn es ein String ist und wenn es mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder wenn es ein oder mehrere Metazeichen enthält.

• exe_path andernfalls.

Argument command_line

Das Zeichenkettenargument command_line ist eine Befehlszeile, die an eine Shell übergeben wird; sie muss mit einem reservierten Shell-Wort beginnen, mit einem speziellen Built-in beginnen oder Metazeichen enthalten.

Open3.capture3('if true; then echo "Foo"; fi') # Shell reserved word.
# => ["Foo\n", "", #<Process::Status: pid 2282025 exit 0>]
Open3.capture3('echo')                         # Built-in.
# => ["\n", "", #<Process::Status: pid 2282092 exit 0>]
Open3.capture3('date > date.tmp')              # Contains meta character.
# => ["", "", #<Process::Status: pid 2282110 exit 0>]

Die Befehlszeile kann auch Argumente und Optionen für den Befehl enthalten.

Open3.capture3('echo "Foo"')
# => ["Foo\n", "", #<Process::Status: pid 2282092 exit 0>]

Argument exe_path

Das Argument exe_path ist eines der folgenden:

• Der Zeichenkettenpfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array mit zwei Elementen, das den Pfad zu einer ausführbaren Datei und die Zeichenkette enthält, die als Name des ausgeführten Prozesses verwendet werden soll.

Beispiel

Open3.capture3('/usr/bin/date')
# => ["Thu Sep 28 05:03:51 PM CDT 2023\n", "", #<Process::Status: pid 2282300 exit 0>]

Ruby ruft die ausführbare Datei direkt auf, ohne Shell und ohne Shell-Erweiterung.

Open3.capture3('doesnt_exist') # Raises Errno::ENOENT

Wenn ein oder mehrere args angegeben sind, ist jedes ein Argument oder eine Option, die an die ausführbare Datei übergeben werden soll.

Open3.capture3('echo', 'C #')
# => ["C #\n", "", #<Process::Status: pid 2282368 exit 0>]
Open3.capture3('echo', 'hello', 'world')
# => ["hello world\n", "", #<Process::Status: pid 2282372 exit 0>]

# File lib/open3.rb, line 1334
def pipeline(*cmds)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  pipeline_run(cmds, opts, [], []) {|ts|
    ts.map(&:value)
  }
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess für jeden der gegebenen cmds durch Aufruf von Process.spawn.

• Leitet die stdout jedes Kindes an die stdin des nächsten Kindes weiter oder, für das letzte Kind, an die stdout des Aufrufers.

• Wartet auf den Abschluss der Kindprozesse.

• Gibt ein Array von Process::Status-Objekten zurück (eines für jedes Kind).

Beispiel

wait_threads = Open3.pipeline('ls', 'grep R')
# => [#<Process::Status: pid 2139200 exit 0>, #<Process::Status: pid 2139202 exit 0>]

Ausgabe

Rakefile
README.md

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env in jedem Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options in jedem Aufruf von Process.spawn; siehe Ausführungsoptionen.

Jedes verbleibende Argument in cmds ist eines von:

• Ein command_line: ein String, der mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder ein oder mehrere Metazeichen enthält.

• Ein exe_path: der String-Pfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array, das einen command_line oder einen exe_path zusammen mit null oder mehr String-Argumenten für den Befehl enthält.

Siehe Argument command_line oder exe_path.

# File lib/open3.rb, line 1104
def pipeline_r(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  pipeline_run(cmds, opts, [out_w], [out_r], &block)
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess für jeden der gegebenen cmds durch Aufruf von Process.spawn.

• Leitet die stdout jedes Kindes an die stdin des nächsten Kindes weiter oder, für das letzte Kind, an die stdout des Aufrufers.

Die Methode wartet nicht auf den Abschluss der Kindprozesse, daher muss der Aufrufer dies tun.

Ohne Block gibt sie ein 2-Element-Array zurück, das Folgendes enthält:

• Den stdout-Stream des letzten Kindprozesses.

• Ein Array von Wait-Threads für alle Kindprozesse.

Beispiel

last_stdout, wait_threads = Open3.pipeline_r('ls', 'grep R')
# => [#<IO:fd 5>, [#<Process::Waiter:0x000055e8de2f9898 dead>, #<Process::Waiter:0x000055e8de2f94b0 sleep>]]
puts last_stdout.read
wait_threads.each do |wait_thread|
  wait_thread.join
end

Ausgabe

Rakefile
README.md

Mit einem gegebenen Block ruft sie den Block mit dem stdout-Stream des letzten Kindprozesses und einem Array der Wait-Threads auf.

Open3.pipeline_r('ls', 'grep R') do |last_stdout, wait_threads|
  puts last_stdout.read
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

Ausgabe

Rakefile
README.md

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env in jedem Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options in jedem Aufruf von Process.spawn; siehe Ausführungsoptionen.

Jedes verbleibende Argument in cmds ist eines von:

• Ein command_line: ein String, der mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder ein oder mehrere Metazeichen enthält.

• Ein exe_path: der String-Pfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array, das einen command_line oder einen exe_path zusammen mit null oder mehr String-Argumenten für den Befehl enthält.

Siehe Argument command_line oder exe_path.

# File lib/open3.rb, line 1014
def pipeline_rw(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  pipeline_run(cmds, opts, [in_r, out_w], [in_w, out_r], &block)
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess für jeden der gegebenen cmds durch Aufruf von Process.spawn.

• Leitet die stdout jedes Kindes an die stdin des nächsten Kindes weiter, oder, für das erste Kind, von der stdin des Aufrufers, oder, für das letzte Kind, an die stdout des Aufrufers.

Die Methode wartet nicht auf den Abschluss der Kindprozesse, daher muss der Aufrufer dies tun.

Ohne Block gibt sie ein 3-Element-Array zurück, das Folgendes enthält:

• Den stdin-Stream des ersten Kindprozesses.

• Den stdout-Stream des letzten Kindprozesses.

• Ein Array von Wait-Threads für alle Kindprozesse.

Beispiel

first_stdin, last_stdout, wait_threads = Open3.pipeline_rw('sort', 'cat -n')
# => [#<IO:fd 20>, #<IO:fd 21>, [#<Process::Waiter:0x000055e8de29ab40 sleep>, #<Process::Waiter:0x000055e8de29a690 sleep>]]
first_stdin.puts("foo\nbar\nbaz")
first_stdin.close # Send EOF to sort.
puts last_stdout.read
wait_threads.each do |wait_thread|
  wait_thread.join
end

Ausgabe

1 bar
2 baz
3 foo

Mit einem gegebenen Block ruft sie den Block mit dem stdin-Stream des ersten Kindes, dem stdout-Stream des letzten Kindes und einem Array der Wait-Threads auf.

Open3.pipeline_rw('sort', 'cat -n') do |first_stdin, last_stdout, wait_threads|
  first_stdin.puts "foo\nbar\nbaz"
  first_stdin.close # send EOF to sort.
  puts last_stdout.read
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

Ausgabe

1 bar
2 baz
3 foo

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env in jedem Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options in jedem Aufruf von Process.spawn; siehe Ausführungsoptionen.

Jedes verbleibende Argument in cmds ist eines von:

• Ein command_line: ein String, der mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder ein oder mehrere Metazeichen enthält.

• Ein exe_path: der String-Pfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array, das einen command_line oder einen exe_path zusammen mit null oder mehr String-Argumenten für den Befehl enthält.

Siehe Argument command_line oder exe_path.

# File lib/open3.rb, line 1272
def pipeline_start(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  if block
    pipeline_run(cmds, opts, [], [], &block)
  else
    ts, = pipeline_run(cmds, opts, [], [])
    ts
  end
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess für jeden der gegebenen cmds durch Aufruf von Process.spawn.

• Wartet nicht auf den Abschluss der Kindprozesse.

Ohne Block gibt sie ein Array der Wait-Threads für alle Kindprozesse zurück.

Beispiel

wait_threads = Open3.pipeline_start('ls', 'grep R')
# => [#<Process::Waiter:0x000055e8de9d2bb0 run>, #<Process::Waiter:0x000055e8de9d2890 run>]
wait_threads.each do |wait_thread|
  wait_thread.join
end

Ausgabe

Rakefile
README.md

Mit einem gegebenen Block ruft sie den Block mit einem Array der Wait-Threads auf.

Open3.pipeline_start('ls', 'grep R') do |wait_threads|
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

Ausgabe

Rakefile
README.md

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env in jedem Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options in jedem Aufruf von Process.spawn; siehe Ausführungsoptionen.

Jedes verbleibende Argument in cmds ist eines von:

• Ein command_line: ein String, der mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder ein oder mehrere Metazeichen enthält.

• Ein exe_path: der String-Pfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array, das einen command_line oder einen exe_path zusammen mit null oder mehr String-Argumenten für den Befehl enthält.

Siehe Argument command_line oder exe_path.

# File lib/open3.rb, line 1195
def pipeline_w(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  pipeline_run(cmds, opts, [in_r], [in_w], &block)
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess für jeden der gegebenen cmds durch Aufruf von Process.spawn.

• Leitet die stdout jedes Kindes an die stdin des nächsten Kindes weiter, oder, für das erste Kind, leitet die stdout des Aufrufers an die stdin des Kindes weiter.

Die Methode wartet nicht auf den Abschluss der Kindprozesse, daher muss der Aufrufer dies tun.

Ohne Block gibt sie ein 2-Element-Array zurück, das Folgendes enthält:

• Den stdin-Stream des ersten Kindprozesses.

• Ein Array von Wait-Threads für alle Kindprozesse.

Beispiel

first_stdin, wait_threads = Open3.pipeline_w('sort', 'cat -n')
# => [#<IO:fd 7>, [#<Process::Waiter:0x000055e8de928278 run>, #<Process::Waiter:0x000055e8de923e80 run>]]
first_stdin.puts("foo\nbar\nbaz")
first_stdin.close # Send EOF to sort.
wait_threads.each do |wait_thread|
  wait_thread.join
end

Ausgabe

1 bar
2 baz
3 foo

Mit einem gegebenen Block ruft sie den Block mit dem stdin-Stream des ersten Kindprozesses und einem Array der Wait-Threads auf.

Open3.pipeline_w('sort', 'cat -n') do |first_stdin, wait_threads|
  first_stdin.puts("foo\nbar\nbaz")
  first_stdin.close # Send EOF to sort.
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

Ausgabe

1 bar
2 baz
3 foo

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env in jedem Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options in jedem Aufruf von Process.spawn; siehe Ausführungsoptionen.

Jedes verbleibende Argument in cmds ist eines von:

• Ein command_line: ein String, der mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder ein oder mehrere Metazeichen enthält.

• Ein exe_path: der String-Pfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array, das einen command_line oder einen exe_path zusammen mit null oder mehr String-Argumenten für den Befehl enthält.

Siehe Argument command_line oder exe_path.

# File lib/open3.rb, line 365
def popen2(*cmd, &block)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  popen_run(cmd, opts, [in_r, out_w], [in_w, out_r], &block)
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess durch Aufruf von Process.spawn mit den gegebenen Argumenten.

• Erstellt die Streams stdin und stdout, die die Standardeingabe und die Standardausgabe im Kindprozess sind.

• Erstellt den Thread wait_thread, der auf den Abschluss des Kindprozesses wartet; der Thread hat die Methode pid, die die Prozess-ID des Kindprozesses zurückgibt.

Ohne Block gibt sie das Array [stdin, stdout, wait_thread] zurück. Der Aufrufer sollte jeden der beiden zurückgegebenen Streams schließen.

stdin, stdout, wait_thread = Open3.popen2('echo')
# => [#<IO:fd 6>, #<IO:fd 7>, #<Process::Waiter:0x00007f58d52dbe98 run>]
stdin.close
stdout.close
wait_thread.pid   # => 2263572
wait_thread.value # => #<Process::Status: pid 2263572 exit 0>

Mit einem gegebenen Block ruft sie den Block mit den drei Variablen (zwei Streams und dem Wait-Thread) auf und gibt den Rückgabewert des Blocks zurück. Der Aufrufer muss die Streams nicht schließen.

Open3.popen2('echo') do |stdin, stdout, wait_thread|
  p stdin
  p stdout
  p wait_thread
  p wait_thread.pid
  p wait_thread.value
end

Ausgabe

#<IO:fd 6>
#<IO:fd 7>
#<Process::Waiter:0x00007f58d59a34b0 sleep>
2263636
#<Process::Status: pid 2263636 exit 0>

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Im Gegensatz zu Process.spawn wartet diese Methode, bis der Kindprozess beendet ist, bevor sie zurückkehrt. Der Aufrufer muss dies also nicht tun.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env im Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options im Aufruf von Process.spawn; siehe Ausführungsoptionen.

Das einzelne erforderliche Argument ist eines der folgenden:

• command_line, wenn es ein String ist und wenn es mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder wenn es ein oder mehrere Metazeichen enthält.

• exe_path andernfalls.

Argument command_line

Das Zeichenkettenargument command_line ist eine Befehlszeile, die an eine Shell übergeben wird; sie muss mit einem reservierten Shell-Wort beginnen, mit einem speziellen Built-in beginnen oder Metazeichen enthalten.

Open3.popen2('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word.
Open3.popen2('echo') {|*args| p args }                         # Built-in.
Open3.popen2('date > date.tmp') {|*args| p args }              # Contains meta character.

Ausgabe (ähnlich für jeden obigen Aufruf)

# => [#<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f7577dfe410 dead>]

Die Befehlszeile kann auch Argumente und Optionen für den Befehl enthalten.

Open3.popen2('echo "Foo"') { |i, o, t| o.gets }
"Foo\n"

Argument exe_path

Das Argument exe_path ist eines der folgenden:

• Der Zeichenkettenpfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array mit zwei Elementen, das den Pfad zu einer ausführbaren Datei und die Zeichenkette enthält, die als Name des ausgeführten Prozesses verwendet werden soll.

Beispiel

Open3.popen2('/usr/bin/date') { |i, o, t| o.gets }
# => "Thu Sep 28 09:41:06 AM CDT 2023\n"

Ruby ruft die ausführbare Datei direkt auf, ohne Shell und ohne Shell-Erweiterung.

Open3.popen2('doesnt_exist') { |i, o, t| o.gets } # Raises Errno::ENOENT

Wenn ein oder mehrere args angegeben sind, ist jedes ein Argument oder eine Option, die an die ausführbare Datei übergeben werden soll.

Open3.popen2('echo', 'C #') { |i, o, t| o.gets }
# => "C #\n"
Open3.popen2('echo', 'hello', 'world') { |i, o, t| o.gets }
# => "hello world\n"

Verwandt

• Open3.popen2e: Macht die Standardeingabe und die zusammengeführte Standardausgabe und den Standardfehler des Kindprozesses als separate Streams verfügbar.

• Open3.popen3: Macht die Standardeingabe-, Standardausgabe- und Standardfehlerstreams des Kindprozesses als separate Streams verfügbar.

# File lib/open3.rb, line 508
def popen2e(*cmd, &block)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[[:out, :err]] = out_w

  popen_run(cmd, opts, [in_r, out_w], [in_w, out_r], &block)
ensure
  if block
    in_r.close
    in_w.close
    out_r.close
    out_w.close
  end
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess durch Aufruf von Process.spawn mit den gegebenen Argumenten.

• Erstellt die Streams stdin, stdout_and_stderr, die die Standardeingabe und die zusammengeführte Standardausgabe und den Standardfehler im Kindprozess sind.

• Erstellt den Thread wait_thread, der auf den Abschluss des Kindprozesses wartet; der Thread hat die Methode pid, die die Prozess-ID des Kindprozesses zurückgibt.

Ohne Block gibt sie das Array [stdin, stdout_and_stderr, wait_thread] zurück. Der Aufrufer sollte jeden der beiden zurückgegebenen Streams schließen.

stdin, stdout_and_stderr, wait_thread = Open3.popen2e('echo')
# => [#<IO:fd 6>, #<IO:fd 7>, #<Process::Waiter:0x00007f7577da4398 run>]
stdin.close
stdout_and_stderr.close
wait_thread.pid   # => 2274600
wait_thread.value # => #<Process::Status: pid 2274600 exit 0>

Mit einem gegebenen Block ruft sie den Block mit den drei Variablen (zwei Streams und dem Wait-Thread) auf und gibt den Rückgabewert des Blocks zurück. Der Aufrufer muss die Streams nicht schließen.

Open3.popen2e('echo') do |stdin, stdout_and_stderr, wait_thread|
  p stdin
  p stdout_and_stderr
  p wait_thread
  p wait_thread.pid
  p wait_thread.value
end

Ausgabe

#<IO:fd 6>
#<IO:fd 7>
#<Process::Waiter:0x00007f75777578c8 sleep>
2274763
#<Process::Status: pid 2274763 exit 0>

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Im Gegensatz zu Process.spawn wartet diese Methode, bis der Kindprozess beendet ist, bevor sie zurückkehrt. Der Aufrufer muss dies also nicht tun.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env im Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options im Aufruf von Process.spawn; siehe Ausführungsoptionen.

Das einzelne erforderliche Argument ist eines der folgenden:

• command_line, wenn es ein String ist und wenn es mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder wenn es ein oder mehrere Metazeichen enthält.

• exe_path andernfalls.

Argument command_line

Das Zeichenkettenargument command_line ist eine Befehlszeile, die an eine Shell übergeben wird; sie muss mit einem reservierten Shell-Wort beginnen, mit einem speziellen Built-in beginnen oder Metazeichen enthalten.

Open3.popen2e('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word.
Open3.popen2e('echo') {|*args| p args }                         # Built-in.
Open3.popen2e('date > date.tmp') {|*args| p args }              # Contains meta character.

Ausgabe (ähnlich für jeden obigen Aufruf)

# => [#<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f7577d8a1f0 dead>]

Die Befehlszeile kann auch Argumente und Optionen für den Befehl enthalten.

Open3.popen2e('echo "Foo"') { |i, o_and_e, t| o_and_e.gets }
"Foo\n"

Argument exe_path

Das Argument exe_path ist eines der folgenden:

• Der Zeichenkettenpfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array mit zwei Elementen, das den Pfad zu einer ausführbaren Datei und die Zeichenkette enthält, die als Name des ausgeführten Prozesses verwendet werden soll.

Beispiel

Open3.popen2e('/usr/bin/date') { |i, o_and_e, t| o_and_e.gets }
# => "Thu Sep 28 01:58:45 PM CDT 2023\n"

Ruby ruft die ausführbare Datei direkt auf, ohne Shell und ohne Shell-Erweiterung.

Open3.popen2e('doesnt_exist') { |i, o_and_e, t| o_and_e.gets } # Raises Errno::ENOENT

Wenn ein oder mehrere args angegeben sind, ist jedes ein Argument oder eine Option, die an die ausführbare Datei übergeben werden soll.

Open3.popen2e('echo', 'C #') { |i, o_and_e, t| o_and_e.gets }
# => "C #\n"
Open3.popen2e('echo', 'hello', 'world') { |i, o_and_e, t| o_and_e.gets }
# => "hello world\n"

Verwandt

• Open3.popen2: Macht die Standardeingabe- und Standardausgabestreams des Kindprozesses als separate Streams verfügbar, ohne Zugriff auf den Standardfehlerstream.

• Open3.popen3: Macht die Standardeingabe-, Standardausgabe- und Standardfehlerstreams des Kindprozesses als separate Streams verfügbar.

# File lib/open3.rb, line 218
def popen3(*cmd, &block)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  err_r, err_w = IO.pipe
  opts[:err] = err_w

  popen_run(cmd, opts, [in_r, out_w, err_w], [in_w, out_r, err_r], &block)
end

Im Grunde ein Wrapper für Process.spawn, der

• Erstellt einen Kindprozess durch Aufruf von Process.spawn mit den gegebenen Argumenten.

• Erstellt die Streams stdin, stdout und stderr, die die Standardeingabe, die Standardausgabe und den Standardfehler im Kindprozess sind.

• Erstellt den Thread wait_thread, der auf den Abschluss des Kindprozesses wartet; der Thread hat die Methode pid, die die Prozess-ID des Kindprozesses zurückgibt.

Ohne Block gibt sie das Array [stdin, stdout, stderr, wait_thread] zurück. Der Aufrufer sollte jeden der drei zurückgegebenen Streams schließen.

stdin, stdout, stderr, wait_thread = Open3.popen3('echo')
# => [#<IO:fd 8>, #<IO:fd 10>, #<IO:fd 12>, #<Process::Waiter:0x00007f58d5428f58 run>]
stdin.close
stdout.close
stderr.close
wait_thread.pid   # => 2210481
wait_thread.value # => #<Process::Status: pid 2210481 exit 0>

Mit einem gegebenen Block ruft sie den Block mit den vier Variablen (drei Streams und dem Wait-Thread) auf und gibt den Rückgabewert des Blocks zurück. Der Aufrufer muss die Streams nicht schließen.

Open3.popen3('echo') do |stdin, stdout, stderr, wait_thread|
  p stdin
  p stdout
  p stderr
  p wait_thread
  p wait_thread.pid
  p wait_thread.value
end

Ausgabe

#<IO:fd 6>
#<IO:fd 7>
#<IO:fd 9>
#<Process::Waiter:0x00007f58d53606e8 sleep>
2211047
#<Process::Status: pid 2211047 exit 0>

Wie Process.spawn hat diese Methode potenzielle Sicherheitslücken, wenn sie mit nicht vertrauenswürdigen Eingaben aufgerufen wird; siehe Command Injection.

Im Gegensatz zu Process.spawn wartet diese Methode, bis der Kindprozess beendet ist, bevor sie zurückkehrt. Der Aufrufer muss dies also nicht tun.

Wenn das erste Argument ein Hash ist, wird es zum führenden Argument env im Aufruf von Process.spawn; siehe Ausführungsumgebung.

Wenn das letzte Argument ein Hash ist, wird es zum nachfolgenden Argument options im Aufruf von Process.spawn; siehe Ausführungsoptionen.

Das einzelne erforderliche Argument ist eines der folgenden:

• command_line, wenn es ein String ist und wenn es mit einem Shell-reservierten Wort oder einem speziellen Built-in beginnt oder wenn es ein oder mehrere Metazeichen enthält.

• exe_path andernfalls.

Argument command_line

Das Zeichenkettenargument command_line ist eine Befehlszeile, die an eine Shell übergeben wird; sie muss mit einem reservierten Shell-Wort beginnen, mit einem speziellen Built-in beginnen oder Metazeichen enthalten.

Open3.popen3('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word.
Open3.popen3('echo') {|*args| p args }                         # Built-in.
Open3.popen3('date > date.tmp') {|*args| p args }              # Contains meta character.

Ausgabe (ähnlich für jeden obigen Aufruf)

[#<IO:(closed)>, #<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f58d52f28c8 dead>]

Die Befehlszeile kann auch Argumente und Optionen für den Befehl enthalten.

Open3.popen3('echo "Foo"') { |i, o, e, t| o.gets }
"Foo\n"

Argument exe_path

Das Argument exe_path ist eines der folgenden:

• Der Zeichenkettenpfad zu einer ausführbaren Datei, die aufgerufen werden soll.

• Ein Array mit zwei Elementen, das den Pfad zu einer ausführbaren Datei und die Zeichenkette enthält, die als Name des ausgeführten Prozesses verwendet werden soll.

Beispiel

Open3.popen3('/usr/bin/date') { |i, o, e, t| o.gets }
# => "Wed Sep 27 02:56:44 PM CDT 2023\n"

Ruby ruft die ausführbare Datei direkt auf, ohne Shell und ohne Shell-Erweiterung.

Open3.popen3('doesnt_exist') { |i, o, e, t| o.gets } # Raises Errno::ENOENT

Wenn ein oder mehrere args angegeben sind, ist jedes ein Argument oder eine Option, die an die ausführbare Datei übergeben werden soll.

Open3.popen3('echo', 'C #') { |i, o, e, t| o.gets }
# => "C #\n"
Open3.popen3('echo', 'hello', 'world') { |i, o, e, t| o.gets }
# => "hello world\n"

Achten Sie darauf, Deadlocks zu vermeiden. Die Ausgabestreams stdout und stderr haben Puffer fester Größe. Daher kann das ausgiebige Lesen aus einem, aber nicht aus dem anderen zu einem Deadlock führen, wenn der nicht gelesene Puffer voll ist. Um dies zu vermeiden, sollten stdout und stderr gleichzeitig gelesen werden (mittels Threads oder IO.select).

Verwandt

• Open3.popen2: Macht die Standardeingabe- und Standardausgabestreams des Kindprozesses als separate Streams verfügbar, ohne Zugriff auf den Standardfehlerstream.

• Open3.popen2e: Macht die Standardeingabe und die zusammengeführte Standardausgabe und den Standardfehler des Kindprozesses als separate Streams verfügbar.