Skrypt powłoki źródłowej do środowiska wewnątrz skryptu ruby ​​

Question

Jeśli piszę skrypt powłoki i chcę "źródło" niektórych zewnętrznych (c-) skryptów powłoki, aby skonfigurować moje środowisko, mogę po prostu wykonywać takie połączenia:

source /file/I/want/to/source.csh

Chcę zastąpić skrypt powłoki, który robi to ze skryptem ruby. Czy mogę zrobić coś podobnego w skrypcie ruby?

Aktualizacja:

prostu próbowałem go test_script.csh:

#!/bin/csh 

setenv HAPPYTIMES True

... i test_script.rb:

#!/usr/bin/env ruby 
system "~/test_script.csh" 
system "echo $HAPPYTIMES"

Niestety, nie ma HAPPYTIMES jak dotąd.

Answer 1

Powód to nie działa dla ciebie jest b/c rubin działa jego komendy system w osobnych powłokach. Tak więc, gdy zakończy się jedno polecenie systemowe, powłoka, z której pochodził twój plik, zostanie zamknięta, a wszelkie zmienne środowiskowe ustawione w tej powłoce zostaną zapomniane.

Jeśli nie znasz nazwy pliku źródłowego do czasu wykonania, to dobrym pomysłem jest Roboprog's answer. Jednakże, jeśli znasz nazwę pliku źródłowego z wyprzedzeniem, możesz zrobić szybkie hackowanie za pomocą linii hashbang.

% echo sourcer.rb 
#!/usr/bin/env ruby 
exec "csh -c 'source #{ARGV[0]} && /usr/bin/env ruby #{ARGV[1]}'" 
% echo my-script.rb 
#!/usr/bin/env ruby sourcer.rb /path/to/file/I/want/to/source.csh 
puts "HAPPYTIMES = #{ENV['HAPPYTIMES']}" 
% ./my-script.rb 
HAPPYTIMES = True 

Wszystko to pomoże tylko użyć zestawu zmiennych w skrypcie Enviroment ruby, nie ustawić je w skorupkach (ponieważ oni zapomnieli, jak tylko zakończy się proces rubinowy). W tym celu utknąłeś w poleceniu source.

Answer 2

system 'source /file/I/want/to/source.sh' 

Nie jestem pewien, czy zrobi to, co chcesz. Wykona polecenie source w podpowłoce. Spróbuj i przekonaj się, że robi to, o co prosisz.

Answer 3

Będziesz musiał napisać funkcję, aby uruchomić coś w rodzaju czynności, a uchwycić wyjście („lewy apostrof” Operation):

/bin/csh -e '. my_script ; env' 

pętli na każdej linii, mecz z czymś jak

/^(\w+)=(.*)$/ 

Następnie użyj pierwszego uchwycenia dopasowania jako nazwy zmiennej, a drugie przechwyć jako wartość var.

(tak, jestem zabezpieczających na fakt, że wiem lepiej niż Perl Ruby, ale podejście byłoby takie samo)

Answer 4

Biorąc pod uwagę następujące Ruby

# Read in the bash environment, after an optional command. 
# Returns Array of key/value pairs. 
def bash_env(cmd=nil) 
    env = `#{cmd + ';' if cmd} printenv` 
    env.split(/\n/).map {|l| l.split(/=/)} 
end 

# Source a given file, and compare environment before and after. 
# Returns Hash of any keys that have changed. 
def bash_source(file) 
    Hash[ bash_env(". #{File.realpath file}") - bash_env() ] 
end 

# Find variables changed as a result of sourcing the given file, 
# and update in ENV. 
def source_env_from(file) 
    bash_source(file).each {|k,v| ENV[k] = v } 
end 

i następujący test.sh:

#!/usr/bin/env bash 
export FOO='bar' 

powinieneś dostać:

irb(main):019:0> source_env_from('test.sh') 
=> {"FOO"=>"bar"} 
irb(main):020:0> ENV['FOO'] 
=> "bar" 

Enjoy!

Answer 5

Miałem ten sam probrem. i postanawiam jak poniżej.

#!/usr/local/bin/ruby 

def source(filename) 
    ENV.replace(eval(`tcsh -c 'source #{filename} && ruby -e "p ENV"'`)) 
end 

p "***old env*****************************" 
p ENV 
source "/file/I/want/to/source.csh" 
p "+++new env+++++++++++++++++++++++++++++" 
p ENV 

"eval" to bardzo potężna metoda. Łatwo przeskoczyć przez proces.

Answer 6

Ulepszanie odpowiedzi @ takeccho ... Czeki i kilka gwizdów. Po pierwsze, środowisko źródłowe jest czyszczone przez env -i, co jest środkiem bezpieczeństwa, ale w niektórych przypadkach może być niepożądane. Po drugie, poprzez set -a, wszystkie zmienne ustawione w pliku są "eksportowane" z powłoki i tym samym importowane do ruby. Jest to przydatne do symulacji/przesłonięcia zachowania w plikach środowiskowych używanych w skryptach init i plikach env systemd.

def ShSource(filename) 
    # Inspired by user takeccho at http://stackoverflow.com/a/26381374/3849157 
    # Sources sh-script or env file and imports resulting environment 
    fail(ArgumentError,"File #{filename} invalid or doesn't exist.") \ 
    unless File.exist?(filename) 

    _newhashstr=`env -i sh -c 'set -a;source #{filename} && ruby -e "p ENV"'` 
    fail(ArgumentError,"Failure to parse or process #{filename} environment")\ 
    unless _newhashstr.match(/^\{("[^"]+"=>".*?",\s*)*("[^"]+"=>".*?")\}$/) 

    _newhash=eval(_newhashstr) 
    %w[ SHLVL PWD _ ].each{|k|_newhash.delete(k) } 
    _newhash.each{|k,v| ENV[k]=v } # ENV does not have #merge! 
end 

Teoria działania: Kiedy ruby ​​wysyła przedmiot ENV korzystając p, robi to w taki sposób, że rubin można odczytać z powrotem w jako obiekt. Tak więc używamy powłoki do źródła pliku docelowego i ruby ​​(w podrzędnej powłoce), aby wyprowadzać środowisko w tej postaci szeregowej. Następnie przechwytujemy wyniki ruby ​​i eval w ramach naszego procesu ruby. Oczywiście nie jest to bez ryzyka, więc aby złagodzić ryzyko, (1) sprawdzamy poprawność podanej nazwy pliku i (2) sprawdzamy za pomocą wyrażenia regularnego, że rzecz, którą otrzymujemy z podpowłoki ruby, jest w rzeczywistości serializowany ciąg mieszający. Gdy jesteśmy tego pewni, robimy eval, który tworzy nowy skrót. Następnie "ręcznie" scalamy hash z ENV, który jest Object, a nie zwykłym Hash. Jeśli byłaby to mieszanka, moglibyśmy użyć metody #merge!.

EDYTOWANIE: sh -a wyeksportowane elementy, takie jak PATH. Musimy również usunąć przed scaleniem mieszania SHLVL i PWD.