A platform for community discussion. Free, open, simple.
# frozen_string_literal: true
require "open3"
class GitUtils
# Shelling out to git can block indefinitely (a wedged git process, a stalled
# filesystem under `.git`, fork pressure on a loaded box). Callers get the
# fallback value instead of hanging.
COMMAND_TIMEOUT_SECONDS = 5
def self.git_version
filesystem_overrides["git_version"] || try_git("git rev-parse HEAD", "unknown")
end
def self.git_branch
filesystem_overrides["git_branch"] || try_git("git branch --show-current", nil) ||
try_git("git config user.discourse-version", "unknown")
end
def self.full_version
filesystem_overrides["full_version"] ||
try_git('git describe --match "v[0-9]*" 2> /dev/null', "unknown")
end
def self.has_commit?(hash)
return false if !hash.match?(/\A[a-f0-9]{40}\Z/)
@has_commit ||= {}
return @has_commit[hash] if @has_commit.key?(hash)
# `echo $?` means the output is git's own exit status: 0 for an ancestor, 1 for
# not, 128 when the commit isn't in the repo at all. `nil` means git never ran,
# which is not an answer, so it isn't memoized.
result =
try_git(
"git merge-base --is-ancestor #{hash} HEAD 2> /dev/null; echo $?",
nil,
# We are deployed from a partial clone, where a commit missing from the
# local graph is otherwise lazily fetched from the remote: a blocking
# network call, with no timeout of its own, to answer what has to stay a
# local question.
env: {
"GIT_NO_LAZY_FETCH" => "1",
},
)
return false if result.nil?
@has_commit[hash] = result == "0"
end
def self.last_commit_date
git_cmd = "git rev-list -1 --no-commit-header --format=%ct HEAD"
seconds = try_git(git_cmd, nil)
seconds.nil? ? nil : DateTime.strptime(seconds, "%s")
end
def self.try_git(git_cmd, default_value, timeout: COMMAND_TIMEOUT_SECONDS, env: {})
value =
begin
capture_stdout(git_cmd, timeout, env)&.strip
rescue StandardError
nil
end
# Can't use `presence` here, ActiveSupport may not be loaded yet
value.nil? || value.empty? ? default_value : value
end
# Only stdout is returned, matching the behaviour of a backtick call. stderr is
# read in its own thread so a chatty command can't fill the pipe and deadlock,
# then passed through to ours, where it used to go directly.
private_class_method def self.capture_stdout(git_cmd, timeout, env)
Open3.popen3(env, git_cmd, pgroup: true) do |stdin, stdout, stderr, wait_thr|
stdin.close
out_reader = Thread.new { stdout.read }
err_reader = Thread.new { stderr.read }
if wait_thr.join(timeout).nil?
kill_process_group(wait_thr.pid)
[out_reader, err_reader].each(&:kill)
STDERR.puts("GitUtils: `#{git_cmd}` timed out after #{timeout}s")
return nil
end
errors = err_reader.value
STDERR.write(errors) if !errors.nil? && !errors.empty?
out_reader.value
end
end
private_class_method def self.kill_process_group(pid)
Process.kill("KILL", -pid)
rescue Errno::ESRCH, Errno::EPERM
# already gone
end
# The `config/git-utils-override.json` file can be used by hosting providers
# to override the git information that Discourse reports in the UI.
private_class_method def self.filesystem_overrides
@filesystem_overrides ||=
begin
JSON.parse(File.read("#{rails_root}/config/git-utils-overrides.json"))
rescue Errno::ENOENT
{}
end
end
private_class_method def self.rails_root
# Can't use `Rails.root` here because GitUtils is `require`'d before Rails is initialized
Pathname.new(File.expand_path("..", __dir__))
end
end