Module: Utils

Extended by:
T::Sig
Defined in:
Library/Homebrew/utils/git.rb,
Library/Homebrew/utils/ast.rb,
Library/Homebrew/utils/svn.rb,
Library/Homebrew/utils/tar.rb,
Library/Homebrew/utils/curl.rb,
Library/Homebrew/utils/fork.rb,
Library/Homebrew/utils/link.rb,
Library/Homebrew/utils/popen.rb,
Library/Homebrew/utils/shell.rb,
Library/Homebrew/utils/bottles.rb,
Library/Homebrew/utils/shebang.rb,
Library/Homebrew/utils/analytics.rb,
Library/Homebrew/utils/inreplace.rb,
Library/Homebrew/utils/git_repository.rb,
Library/Homebrew/extend/os/mac/utils/bottles.rb,
Library/Homebrew/extend/os/mac/utils/analytics.rb,
Library/Homebrew/extend/os/linux/utils/analytics.rb

Overview

typed: strict frozen_string_literal: true

Defined Under Namespace

Modules: AST, Analytics, Bottles, Curl, Git, Inreplace, Link, Shebang, Shell, Svn, Tar

Class Method Summary collapse

Class Method Details

.git_branch(repo = Pathname.pwd, safe: true) ⇒ Object 


42
43
44
45
 
# File 'Library/Homebrew/utils/git_repository.rb', line 42

def self.git_branch(repo = Pathname.pwd, safe: true)
  repo = Pathname(repo).extend(GitRepositoryExtension)
  repo.git_branch(safe: safe)
end

.git_commit_message(repo = Pathname.pwd, commit: "HEAD", safe: true) ⇒ Object 


55
56
57
58
 
# File 'Library/Homebrew/utils/git_repository.rb', line 55

def self.git_commit_message(repo = Pathname.pwd, commit: "HEAD", safe: true)
  repo = Pathname(repo).extend(GitRepositoryExtension)
  repo.git_commit_message(commit, safe: safe)
end

.git_head(repo = Pathname.pwd, length: nil, safe: true) ⇒ Object 


15
16
17
18
19
20
 
# File 'Library/Homebrew/utils/git_repository.rb', line 15

def self.git_head(repo = Pathname.pwd, length: nil, safe: true)
  return git_short_head(repo, length: length) if length.present?

  repo = Pathname(repo).extend(GitRepositoryExtension)
  repo.git_head(safe: safe)
end

.git_short_head(repo = Pathname.pwd, length: nil, safe: true) ⇒ Object 


30
31
32
33
 
# File 'Library/Homebrew/utils/git_repository.rb', line 30

def self.git_short_head(repo = Pathname.pwd, length: nil, safe: true)
  repo = Pathname(repo).extend(GitRepositoryExtension)
  repo.git_short_head(length: length, safe: safe)
end

.popen(args, mode, options = {}) ⇒ Object 


46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'Library/Homebrew/utils/popen.rb', line 46

def self.popen(args, mode, options = {})
  IO.popen("-", mode) do |pipe|
    if pipe
      return pipe.read unless block_given?

      yield pipe
    else
      options[:err] ||= "/dev/null" unless ENV["HOMEBREW_STDERR"]
      begin
        exec(*args, options)
      rescue Errno::ENOENT
        $stderr.puts "brew: command not found: #{args[0]}" unless options[:err] == :close
        exit! 127
      rescue SystemCallError
        $stderr.puts "brew: exec failed: #{args[0]}" unless options[:err] == :close
        exit! 1
      end
    end
  end
end

.popen_read(*args, safe: false, **options, &block) ⇒ Object

Raises:


8
9
10
11
12
13
 
# File 'Library/Homebrew/utils/popen.rb', line 8

def self.popen_read(*args, safe: false, **options, &block)
  output = popen(args, "rb", options, &block)
  return output if !safe || $CHILD_STATUS.success?

  raise ErrorDuringExecution.new(args, status: $CHILD_STATUS, output: [[:stdout, output]])
end

.popen_write(*args, safe: false, **options) ⇒ Object

Raises:


19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'Library/Homebrew/utils/popen.rb', line 19

def self.popen_write(*args, safe: false, **options)
  output = ""
  popen(args, "w+b", options) do |pipe|
    # Before we yield to the block, capture as much output as we can
    loop do
      output += pipe.read_nonblock(IO_DEFAULT_BUFFER_SIZE)
    rescue IO::WaitReadable, EOFError
      break
    end

    yield pipe
    pipe.close_write
    IO.select([pipe])

    # Capture the rest of the output
    output += pipe.read
    output.freeze
  end
  return output if !safe || $CHILD_STATUS.success?

  raise ErrorDuringExecution.new(args, status: $CHILD_STATUS, output: [[:stdout, output]])
end

.rewrite_child_error(child_error) ⇒ Object 


8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'Library/Homebrew/utils/fork.rb', line 8

def self.rewrite_child_error(child_error)
  error = if child_error.inner["cmd"] &&
             child_error.inner_class == ErrorDuringExecution
    ErrorDuringExecution.new(child_error.inner["cmd"],
                             status: child_error.inner["status"],
                             output: child_error.inner["output"])
  elsif child_error.inner["cmd"] &&
        child_error.inner_class == BuildError
    # We fill `BuildError#formula` and `BuildError#options` in later,
    # when we rescue this in `FormulaInstaller#build`.
    BuildError.new(nil, child_error.inner["cmd"],
                   child_error.inner["args"], child_error.inner["env"])
  elsif child_error.inner_class == Interrupt
    Interrupt.new
  else
    # Everything other error in the child just becomes a RuntimeError.
    RuntimeError.new(child_error.message)
  end

  error.set_backtrace child_error.backtrace

  error
end

.safe_fork ⇒ Object 


32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'Library/Homebrew/utils/fork.rb', line 32

def self.safe_fork
  Dir.mktmpdir("homebrew", HOMEBREW_TEMP) do |tmpdir|
    UNIXServer.open("#{tmpdir}/socket") do |server|
      read, write = IO.pipe

      pid = fork do
        # bootsnap doesn't like these forked processes
        ENV["HOMEBREW_NO_BOOTSNAP"] = "1"

        ENV["HOMEBREW_ERROR_PIPE"] = server.path
        server.close
        read.close
        write.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
        yield
      rescue Exception => e # rubocop:disable Lint/RescueException
        error_hash = JSON.parse e.to_json

        # Special case: We need to recreate ErrorDuringExecutions
        # for proper error messages and because other code expects
        # to rescue them further down.
        if e.is_a?(ErrorDuringExecution)
          error_hash["cmd"] = e.cmd
          error_hash["status"] = if e.status.is_a?(Process::Status)
            {
              exitstatus: e.status.exitstatus,
              termsig:    e.status.termsig,
            }
          else
            e.status
          end
          error_hash["output"] = e.output
        end

        write.puts error_hash.to_json
        write.close

        exit!
      else
        exit!(true)
      end

      ignore_interrupts(:quietly) do # the child will receive the interrupt and marshal it back
        begin
          socket = server.accept_nonblock
        rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINTR
          retry unless Process.waitpid(T.must(pid), Process::WNOHANG)
        else
          socket.send_io(write)
          socket.close
        end
        write.close
        data = read.read
        read.close
        Process.wait(T.must(pid)) unless socket.nil?

        # 130 is the exit status for a process interrupted via Ctrl-C.
        # We handle it here because of the possibility of an interrupted process terminating
        # without writing its Interrupt exception to the error pipe.
        raise Interrupt if $CHILD_STATUS.exitstatus == 130

        if data.present?
          error_hash = JSON.parse(T.must(data.lines.first))

          e = ChildProcessError.new(error_hash)

          raise rewrite_child_error(e)
        end

        raise "Forked child process failed: #{$CHILD_STATUS}" unless $CHILD_STATUS.success?
      end
    end
  end
end

.safe_popen_read(*args, **options, &block) ⇒ Object 


15
16
17
 
# File 'Library/Homebrew/utils/popen.rb', line 15

def self.safe_popen_read(*args, **options, &block)
  popen_read(*args, safe: true, **options, &block)
end

.safe_popen_write(*args, **options, &block) ⇒ Object 


42
43
44
 
# File 'Library/Homebrew/utils/popen.rb', line 42

def self.safe_popen_write(*args, **options, &block)
  popen_write(*args, safe: true, **options, &block)
end