buildvars

var (
	// BinaryName is the name of the dgraph binary at build time (what
	// `go build -o` writes, matching upstream's $(BIN) in
	// dgraph/Makefile) and at runtime (what compose files and test
	// harnesses invoke as /gobin/$BIN). Upstream default: "dgraph".
	// Forks rename via env or SetDefault, e.g. "myfork-dgraph".
	//
	// The env-var name remains BIN for backward compatibility with
	// shell scripts, Makefiles, and CI configs that reference $(BIN)
	// or ${BIN} directly. The Go identifier is BinaryName because Go
	// callers benefit from the more descriptive symbol.
	BinaryName = newVar("BIN", "dgraph")

	// DockerImage is the Docker image tag (without :tag suffix) used by
	// the Makefile local-image and docker-image targets and by the
	// compose generator's --image default. Upstream default:
	// "dgraph/dgraph".
	DockerImage = newVar("DOCKER_IMAGE", "dgraph/dgraph")

	// BuildImage is the toolchain image for the Dockerfile build stage.
	// Upstream uses an OS base image; forks may substitute a hardened
	// toolchain such as Chainguard go-fips. Paired with BuildTag.
	BuildImage = newVar("BUILD_IMAGE", "ubuntu")

	// BuildTag is the tag for BuildImage. Upstream default: "24.04".
	BuildTag = newVar("BUILD_TAG", "24.04")

	// RuntimeImage is the runtime base image for the Dockerfile runtime
	// stage. Paired with RuntimeTag.
	RuntimeImage = newVar("RUNTIME_IMAGE", "ubuntu")

	// RuntimeTag is the tag for RuntimeImage.
	RuntimeTag = newVar("RUNTIME_TAG", "24.04")

	// BuildTags is the space-separated list of Go build tags passed to
	// `go build` via -tags. The upstream default composes "jemalloc"
	// (the well-known libjemalloc tag) with any tags a fork adds via
	// [CustomBuildTags]. The Makefile and this Var share the same
	// composition, so `make` and direct `go run` agree on the final
	// tag set.
	//
	// "jemalloc" is meaningful only on Linux and macOS; the Makefile
	// omits it on other hosts. Go code reading BuildTags treats the
	// value as informational and makes no OS-aware decisions. The
	// Makefile handles OS gating for the actual `go build` invocation.
	BuildTags = newDerivedVar("BUILD_TAGS", func() string {
		base := "jemalloc"
		extra := CustomBuildTags.Get()
		if extra == "" {
			return base
		}
		return base + " " + extra
	})

	// CustomBuildTags is the list of additional Go build tags a fork or
	// downstream consumer appends to [BuildTags]. Upstream default: empty.
	// Consumers needing compile-time code paths set this to
	// space-separated tag names, e.g. "myfork fips". The Makefile
	// concatenates CustomBuildTags onto BuildTags, so callers read
	// BuildTags to see the final tag set.
	CustomBuildTags = newVar("CUSTOM_BUILD_TAGS", "")

	// GoRunTags is the build-tag list passed via -tags to `go run`
	// invocations from Makefile helper recipes. For example, `build-env`
	// runs `go run -tags=$(GO_RUN_TAGS) ./buildvars/cmd/buildvars` so
	// the buildvars CLI picks up a fork's init-time default overrides.
	//
	// Distinct from [BuildTags]: GoRunTags contains only the tags
	// needed to trigger fork-specific init()-time registration,
	// typically just a fork's primary tag. BuildTags adds "jemalloc"
	// and any other compile-time-only tags a long-running binary needs.
	//
	// Upstream default: empty. Forks override via an init()-time
	// SetDefault call in the package their registration tag guards.
	GoRunTags = newVar("GO_RUN_TAGS", "")

	// DgraphVersion is the version tag baked into the Docker image and
	// into the binary's version output. Upstream default: "local",
	// the development build tag. CI overrides via env to the release
	// tag on tagged builds, e.g. "v25.3.0".
	DgraphVersion = newVar("DGRAPH_VERSION", "local")

	// Build is the short git commit SHA of the build source, baked
	// into the binary's version output via -ldflags -X. The default
	// computes at Get() time from `git rev-parse --short HEAD` and is
	// empty when the build happens outside a git working copy.
	Build = newDerivedVar("BUILD", func() string {
		return shellOutput("git", "rev-parse", "--short", "HEAD")
	})

	// BuildDate is the commit timestamp of the build source, baked
	// into the binary via -ldflags -X. The default computes from
	// `git log -1 --format=%ci`.
	BuildDate = newDerivedVar("BUILD_DATE", func() string {
		return shellOutput("git", "log", "-1", "--format=%ci")
	})

	// BuildBranch is the git branch of the build source, baked in via
	// -ldflags -X. The default computes from
	// `git rev-parse --abbrev-ref HEAD`.
	BuildBranch = newDerivedVar("BUILD_BRANCH", func() string {
		return shellOutput("git", "rev-parse", "--abbrev-ref", "HEAD")
	})

	// BuildCodename is a human-readable name for the release family,
	// baked into the binary via -ldflags -X. Upstream default: "dgraph";
	// CI overrides per release.
	BuildCodename = newVar("BUILD_CODENAME", "dgraph")

	// BuildVersion is the full version string baked into the binary,
	// e.g. "v25.3.0-5-gabc1234". The default computes from
	// `git describe --always --tags` and is empty when git is
	// unavailable. CI release builds override via env to the exact
	// release tag.
	BuildVersion = newDerivedVar("BUILD_VERSION", func() string {
		return shellOutput("git", "describe", "--always", "--tags")
	})

	// LinuxGobin is the host directory holding the Linux-built dgraph
	// binary used for bind-mounting into containers. On Linux, usually
	// $GOPATH/bin (native); on macOS, a separate $GOPATH/linux_<arch>/
	// directory so the cross-compiled Linux binary does not collide
	// with the Mach-O host binary. The default computes at Get() time
	// from $GOPATH + runtime.GOARCH.
	LinuxGobin = newDerivedVar("LINUX_GOBIN", func() string {
		gopath := os.Getenv("GOPATH")
		if gopath == "" {
			return ""
		}
		return gopath + "/linux_" + runtime.GOARCH
	})

	// GoBinDgraphPath is the in-container path to the dgraph binary:
	// the bind-mounted /gobin directory joined with the binary name.
	// Used by jepsen's --local-binary default and by the compose
	// generator for services configured with LocalBin. Derived from
	// [BinaryName] at Get() time so the path tracks the binary name.
	GoBinDgraphPath = newDerivedVar("GOBIN_DGRAPH_PATH", func() string {
		return "/gobin/" + BinaryName.Get()
	})

	// HostGopathDgraphPath is the host-side absolute path to the built
	// dgraph binary, $GOPATH/bin/<BinaryName>. Used by testutil and
	// t/t.go to locate the binary on the runner host outside
	// containers. Returns empty when $GOPATH is unset so callers can
	// fall back to build.Default.GOPATH or their own resolution.
	// Derived from [BinaryName] at Get() time.
	HostGopathDgraphPath = newDerivedVar("HOST_GOPATH_DGRAPH_PATH", func() string {
		gopath := os.Getenv("GOPATH")
		if gopath == "" {
			return ""
		}
		return gopath + "/bin/" + BinaryName.Get()
	})
)

var All = []*Var{
	BinaryName,
	DockerImage,
	BuildImage,
	BuildTag,
	RuntimeImage,
	RuntimeTag,
	BuildTags,
	CustomBuildTags,
	GoRunTags,
	DgraphVersion,
	Build,
	BuildDate,
	BuildBranch,
	BuildCodename,
	BuildVersion,
	LinuxGobin,
	GoBinDgraphPath,
	HostGopathDgraphPath,
}

var FIPS140CryptoRestricted = false