Jak wywoływać polecenia powłoki z Ruby

Jak wywoływać polecenia powłoki z wnętrza programu Ruby? Jak mogę uzyskać dane wyjściowe z tych poleceń z powrotem do Ruby?

To wyjaśnienie opiera się na skomentowanym skrypcie Ruby od mojego znajomego. Jeśli chcesz ulepszyć skrypt, możesz go zaktualizować pod linkiem.

Po pierwsze, zauważ, że gdy Ruby woła powłokę, zwykle wywołuje /bin/sh, a nie Bash. Niektóre składnie Bash nie są obsługiwane przez /bin/shwszystkie systemy.

Oto sposoby wykonania skryptu powłoki:

cmd = "echo 'hi'" # Sample string that can be used

1. Kernel#` , powszechnie nazywane backticks - `cmd`

   To jest jak wiele innych języków, w tym Bash, PHP i Perl.

   Zwraca wynik (tj. Standardowe wyjście) polecenia powłoki.

   Dokumenty: http://ruby-doc.org/core/Kernel.html#method-i-60

   value = `echo 'hi'`
   value = `#{cmd}`
   

2. Wbudowana składnia, %x( cmd )

   Po xznaku znajduje się separator, którym może być dowolny znak. Jeśli separator jest jednym z bohaterów (, [, {, lub <, dosłowne składa się ze znaków aż do ogranicznika dopasowanie zamknięcia, z uwzględnieniem zagnieżdżonych par ogranicznik. Dla wszystkich innych ograniczników literał obejmuje znaki aż do następnego wystąpienia znaku ogranicznika. Interpolacja ciągów #{ ... }jest dozwolona.

   Zwraca wynik (tj. Standardowe wyjście) polecenia powłoki, podobnie jak backsticks.

   Dokumenty: https://docs.ruby-lang.org/en/master/syntax/literals_rdoc.html#label-Percent+Strings

   value = %x( echo 'hi' )
   value = %x[ #{cmd} ]

3. Kernel#system

   Wykonuje podane polecenie w podpowłoce.

   Zwraca, truejeśli polecenie zostało znalezione i uruchomione pomyślnie, w falseprzeciwnym razie.

   Dokumenty: http://ruby-doc.org/core/Kernel.html#method-i-system

   wasGood = system( "echo 'hi'" )
   wasGood = system( cmd )

4. Kernel#exec

   Zastępuje bieżący proces, uruchamiając dane polecenie zewnętrzne.

   Nie zwraca żadnych, aktualny proces jest zastępowany i nigdy nie jest kontynuowany.

   Dokumenty: http://ruby-doc.org/core/Kernel.html#method-i-exec

   exec( "echo 'hi'" )
   exec( cmd ) # Note: this will never be reached because of the line above

Oto kilka dodatkowych porad: $?które są takie same jak $CHILD_STATUS, uzyskują dostęp do statusu ostatniego wykonanego polecenia systemowego, jeśli używasz backsticks, system()lub %x{}. Następnie możesz uzyskać dostęp do właściwości exitstatusi pid:

$?.exitstatus

Więcej informacji można znaleźć w:

• http://www.elctech.com/blog/im-in-ur-commandline-executin-ma-commands
• http://blog.jayfields.com/2006/06/ruby-kernel-system-exec-and-x.html
• http://tech.natemurray.com/2007/03/ruby-shell-commands.html

Oto schemat blokowy oparty na „ Kiedy używać każdej metody uruchamiania podprocesu w Rubim ”. Zobacz także: „ Oszukuj aplikację, aby pomyślała, że ​​jej standardowe wyjście to terminal, a nie potok ”.

Lubię to robić, używając %xliterału, co ułatwia (i czyta!) Używanie cudzysłowów w poleceniu, tak jak poniżej:

directorylist = %x[find . -name '*test.rb' | sort]

Które w tym przypadku zapełni listę plików wszystkimi plikami testowymi w bieżącym katalogu, które można przetwarzać zgodnie z oczekiwaniami:

directorylist.each do |filename|
  filename.chomp!
  # work with file
end

Oto najlepszy artykuł, moim zdaniem, na temat uruchamiania skryptów powłoki w Rubim: „ 6 sposobów uruchamiania poleceń powłoki w Rubim ”.

Jeśli potrzebujesz tylko wyjścia, użyj backsticksa.

Potrzebowałem bardziej zaawansowanych rzeczy, takich jak STDOUT i STDERR, więc użyłem klejnotu Open4. Wszystkie metody zostały tam wyjaśnione.

Moim ulubionym jest Open3

  require "open3"

  Open3.popen3('nroff -man') { |stdin, stdout, stderr| ... }

Wybierając między tymi mechanizmami, należy rozważyć następujące rzeczy:

1. Czy chcesz po prostu stdout, czy też potrzebujesz stderr? A nawet wyodrębniony?
2. Jak duży jest twój wynik? Czy chcesz zachować cały wynik w pamięci?
3. Czy chcesz przeczytać niektóre dane wyjściowe, gdy podproces jest nadal uruchomiony?
4. Potrzebujesz kodów wynikowych?
5. Czy potrzebujesz obiektu Ruby, który reprezentuje proces i pozwala zabijać go na żądanie?

Może trzeba coś od prostych backticks ( ``) system(), a IO.popendo pełnowymiarową Kernel.fork/ Kernel.execz IO.pipei IO.select.

Możesz także wrzucić limity czasu do miksu, jeśli podproces trwa zbyt długo.

Niestety, to bardzo zależy .

Jeszcze jedna opcja:

Kiedy ty:

• potrzebujesz stderr i stdout
• nie mogę / nie użyję Open3 / Open4 (generują wyjątki w NetBeans na moim Macu, nie wiem dlaczego)

Możesz użyć przekierowania powłoki:

puts %x[cat bogus.txt].inspect
  => ""

puts %x[cat bogus.txt 2>&1].inspect
  => "cat: bogus.txt: No such file or directory\n"

2>&1Składnia działa na Linux , Mac i systemu Windows od wczesnych dni od MS-DOS.

Zdecydowanie nie jestem ekspertem od Ruby, ale spróbuję:

$ irb 
system "echo Hi"
Hi
=> true

Powinieneś być także w stanie robić takie rzeczy jak:

cmd = 'ls'
system(cmd)

Powyższe odpowiedzi są już dość świetne, ale naprawdę chcę udostępnić następujący artykuł podsumowujący: „ 6 sposobów uruchamiania poleceń powłoki w Rubim ”

Zasadniczo mówi nam:

Kernel#exec:

exec 'echo "hello $HOSTNAME"'

systemi $?:

system 'false' 
puts $?

Backticks (`):

today = `date`

IO#popen:

IO.popen("date") { |f| puts f.gets }

Open3#popen3 - stdlib:

require "open3"
stdin, stdout, stderr = Open3.popen3('dc') 

Open4#popen4 -- klejnot:

require "open4" 
pid, stdin, stdout, stderr = Open4::popen4 "false" # => [26327, #<IO:0x6dff24>, #<IO:0x6dfee8>, #<IO:0x6dfe84>]

Jeśli naprawdę potrzebujesz Bash, zgodnie z notatką w „najlepszej” odpowiedzi.

Po pierwsze, zauważ, że gdy Ruby woła powłokę, zwykle wywołuje /bin/sh, a nie Bash. Niektóre składnie Bash nie są obsługiwane przez /bin/shwszystkie systemy.

Jeśli chcesz użyć Bash, wstaw bash -c "your Bash-only command"żądaną metodę wywoływania:

quick_output = system("ls -la")

quick_bash = system("bash -c 'ls -la'")

Testować:

system("echo $SHELL")
system('bash -c "echo $SHELL"')

Lub jeśli działasz istniejący plik skryptu, taki jak

script_output = system("./my_script.sh")

Ruby powinna uszanować shebang, ale zawsze możesz go użyć

system("bash ./my_script.sh")

dla pewności, chociaż /bin/shbieg może być niewielki /bin/bash, prawdopodobnie tego nie zauważysz.

Możesz także użyć operatorów wstecznych (`), podobnych do Perla:

directoryListing = `ls /`
puts directoryListing # prints the contents of the root directory

Przydatne, jeśli potrzebujesz czegoś prostego.

Wybór metody zależy dokładnie od tego, co próbujesz osiągnąć; sprawdź dokumentację, aby uzyskać więcej informacji na temat różnych metod.

Możemy to osiągnąć na wiele sposobów.

Używanie Kernel#exec, nic po wykonaniu tego polecenia:

exec('ls ~')

Za pomocą backticks or %x

`ls ~`
=> "Applications\nDesktop\nDocuments"
%x(ls ~)
=> "Applications\nDesktop\nDocuments"

Za pomocą Kernel#systempolecenia zwraca, truejeśli się powiedzie, falsejeśli się nie powiedzie i zwraca, niljeśli wykonanie polecenia się nie powiedzie:

system('ls ~')
=> true

Najprostszym sposobem jest na przykład:

reboot = `init 6`
puts reboot

Korzystając z odpowiedzi tutaj i powiązanych w odpowiedzi Mihai, stworzyłem funkcję, która spełnia następujące wymagania:

1. Starannie rejestruje STDOUT i STDERR, aby nie „wyciekły”, gdy mój skrypt jest uruchamiany z konsoli.
2. Umożliwia przekazywanie argumentów do powłoki jako tablicy, więc nie musisz się martwić o ucieczkę.
3. Przechwytuje status wyjścia polecenia, aby było jasne, kiedy wystąpił błąd.

Jako bonus, ten zwróci również STDOUT w przypadkach, gdy polecenie powłoki zakończy się pomyślnie (0) i umieści cokolwiek w STDOUT. W ten sposób różni się od system, co truew takich przypadkach po prostu zwraca .

Kod następuje. Szczególną funkcją jest system_quietly:

require 'open3'

class ShellError < StandardError; end

#actual function:
def system_quietly(*cmd)
  exit_status=nil
  err=nil
  out=nil
  Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thread|
    err = stderr.gets(nil)
    out = stdout.gets(nil)
    [stdin, stdout, stderr].each{|stream| stream.send('close')}
    exit_status = wait_thread.value
  end
  if exit_status.to_i > 0
    err = err.chomp if err
    raise ShellError, err
  elsif out
    return out.chomp
  else
    return true
  end
end

#calling it:
begin
  puts system_quietly('which', 'ruby')
rescue ShellError
  abort "Looks like you don't have the `ruby` command. Odd."
end

#output: => "/Users/me/.rvm/rubies/ruby-1.9.2-p136/bin/ruby"

Nie zapomnij spawnpolecenia utworzenia procesu w tle w celu wykonania określonego polecenia. Możesz nawet poczekać na jej zakończenie, korzystając z Processklasy i zwróconych pid:

pid = spawn("tar xf ruby-2.0.0-p195.tar.bz2")
Process.wait pid

pid = spawn(RbConfig.ruby, "-eputs'Hello, world!'")
Process.wait pid

Dokument mówi: Ta metoda jest podobna do tej, #systemale nie czeka na zakończenie polecenia.

Jeśli masz bardziej złożony przypadek niż zwykły przypadek, z którym nie można sobie poradzić ``, sprawdź Kernel.spawn(). Wydaje się, że jest to najbardziej ogólny / w pełni funkcjonalny program Ruby do wykonywania poleceń zewnętrznych.

Możesz go użyć do:

• utwórz grupy procesów (Windows).
• przekierowanie do, wyjście, błąd do plików / siebie.
• ustaw env vars, umask.
• zmień katalog przed wykonaniem polecenia.
• ustawić limity zasobów dla procesora / danych / itp.
• Zrób wszystko, co można zrobić z innymi opcjami w innych odpowiedziach, ale z większym kodem.

Dokumentacja Ruby ma wystarczająco dobrych przykładów:

env: hash
  name => val : set the environment variable
  name => nil : unset the environment variable
command...:
  commandline                 : command line string which is passed to the standard shell
  cmdname, arg1, ...          : command name and one or more arguments (no shell)
  [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
options: hash
  clearing environment variables:
    :unsetenv_others => true   : clear environment variables except specified by env
    :unsetenv_others => false  : dont clear (default)
  process group:
    :pgroup => true or 0 : make a new process group
    :pgroup => pgid      : join to specified process group
    :pgroup => nil       : dont change the process group (default)
  create new process group: Windows only
    :new_pgroup => true  : the new process is the root process of a new process group
    :new_pgroup => false : dont create a new process group (default)
  resource limit: resourcename is core, cpu, data, etc.  See Process.setrlimit.
    :rlimit_resourcename => limit
    :rlimit_resourcename => [cur_limit, max_limit]
  current directory:
    :chdir => str
  umask:
    :umask => int
  redirection:
    key:
      FD              : single file descriptor in child process
      [FD, FD, ...]   : multiple file descriptor in child process
    value:
      FD                        : redirect to the file descriptor in parent process
      string                    : redirect to file with open(string, "r" or "w")
      [string]                  : redirect to file with open(string, File::RDONLY)
      [string, open_mode]       : redirect to file with open(string, open_mode, 0644)
      [string, open_mode, perm] : redirect to file with open(string, open_mode, perm)
      [:child, FD]              : redirect to the redirected file descriptor
      :close                    : close the file descriptor in child process
    FD is one of follows
      :in     : the file descriptor 0 which is the standard input
      :out    : the file descriptor 1 which is the standard output
      :err    : the file descriptor 2 which is the standard error
      integer : the file descriptor of specified the integer
      io      : the file descriptor specified as io.fileno
  file descriptor inheritance: close non-redirected non-standard fds (3, 4, 5, ...) or not
    :close_others => false : inherit fds (default for system and exec)
    :close_others => true  : dont inherit (default for spawn and IO.popen)

Metoda backticks (`) jest najłatwiejszą do wywoływania poleceń powłoki z Ruby. Zwraca wynik polecenia powłoki:

     url_request = 'http://google.com'
     result_of_shell_command = `curl #{url_request}`

Biorąc pod uwagę polecenie attrib:

require 'open3'

a="attrib"
Open3.popen3(a) do |stdin, stdout, stderr|
  puts stdout.read
end

Przekonałem się, że chociaż ta metoda nie jest tak niezapomniana jak

system("thecommand")

lub

`thecommand`

w backticks, dobrą rzeczą w tej metodzie w porównaniu z innymi metodami jest to, że backticks nie pozwalają mi putsna polecenie, które wykonuję / przechowuję polecenie, które chcę uruchomić w zmiennej, i system("thecommand")nie wydaje mi się, aby uzyskać wynik, podczas gdy ta metoda pozwala mi robić obie te rzeczy i umożliwia mi niezależny dostęp do stdin, stdout i stderr.

Zobacz „ Wykonywanie poleceń w Rubim ” i dokumentację Open3 Ruby .

To nie jest tak naprawdę odpowiedź, ale może ktoś uzna ją za przydatną:

Kiedy używasz TK GUI w systemie Windows i musisz wywoływać polecenia powłoki z rubyw, zawsze pojawi się denerwujące okno CMD na mniej niż sekundę.

Aby tego uniknąć, możesz użyć:

WIN32OLE.new('Shell.Application').ShellExecute('ipconfig > log.txt','','','open',0)

lub

WIN32OLE.new('WScript.Shell').Run('ipconfig > log.txt',0,0)

Oba będą przechowywać dane ipconfigwyjściowe w środku log.txt, ale nie pojawią się żadne okna.

Musisz zajrzeć do require 'win32ole'skryptu.

system(), exec()i spawn()wszystkie pojawią się w tym irytującym oknie podczas korzystania z TK i rubyw.

Oto fajny, którego używam w skrypcie ruby ​​w systemie OS X (dzięki czemu mogę uruchomić skrypt i uzyskać aktualizację nawet po przełączeniu się z okna):

cmd = %Q|osascript -e 'display notification "Server was reset" with title "Posted Update"'|
system ( cmd )