From 766dd89ffa198a315b043230f904636461c41efe Mon Sep 17 00:00:00 2001 From: Ophestra Date: Tue, 21 Oct 2025 01:49:36 +0900 Subject: [PATCH] internal: clean up build strings These names are less ambiguous and should be understandable without reading the source code. Signed-off-by: Ophestra --- cmd/hpkg/proc.go | 6 +++--- cmd/hsu/main.go | 12 +++++++++++- cmd/hsu/package.nix | 2 +- cmd/hsu/path.go | 20 -------------------- dist/release.sh | 8 ++++---- internal/comp.go | 17 ----------------- internal/path.go | 20 ++++++++++---------- internal/path_test.go | 1 - internal/version.go | 19 +++++++++++++++++++ package.nix | 6 +++--- 10 files changed, 51 insertions(+), 60 deletions(-) delete mode 100644 cmd/hsu/path.go delete mode 100644 internal/comp.go create mode 100644 internal/version.go diff --git a/cmd/hpkg/proc.go b/cmd/hpkg/proc.go index 7088910..013e0b6 100644 --- a/cmd/hpkg/proc.go +++ b/cmd/hpkg/proc.go @@ -14,7 +14,7 @@ import ( "hakurei.app/message" ) -var hakureiPath = internal.MustHakureiPath() +var hakureiPathVal = internal.MustHakureiPath().String() func mustRunApp(ctx context.Context, msg message.Msg, config *hst.Config, beforeFail func()) { var ( @@ -27,9 +27,9 @@ func mustRunApp(ctx context.Context, msg message.Msg, config *hst.Config, before log.Fatalf("cannot pipe: %v", err) } else { if msg.IsVerbose() { - cmd = exec.CommandContext(ctx, hakureiPath.String(), "-v", "app", "3") + cmd = exec.CommandContext(ctx, hakureiPathVal, "-v", "app", "3") } else { - cmd = exec.CommandContext(ctx, hakureiPath.String(), "app", "3") + cmd = exec.CommandContext(ctx, hakureiPathVal, "app", "3") } cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr cmd.ExtraFiles = []*os.File{r} diff --git a/cmd/hsu/main.go b/cmd/hsu/main.go index 27b97b5..5901087 100644 --- a/cmd/hsu/main.go +++ b/cmd/hsu/main.go @@ -26,6 +26,11 @@ const ( identityMax = 9999 ) +// hakureiPath is the absolute path to Hakurei. +// +// This is set by the linker. +var hakureiPath string + func main() { log.SetFlags(0) log.SetPrefix("hsu: ") @@ -43,13 +48,18 @@ func main() { log.Fatal("this program must not be started by root") } + if !path.IsAbs(hakureiPath) { + log.Fatal("this program is compiled incorrectly") + return + } + var toolPath string pexe := path.Join("/proc", strconv.Itoa(os.Getppid()), "exe") if p, err := os.Readlink(pexe); err != nil { log.Fatalf("cannot read parent executable path: %v", err) } else if strings.HasSuffix(p, " (deleted)") { log.Fatal("hakurei executable has been deleted") - } else if p != mustCheckPath(hmain) { + } else if p != hakureiPath { log.Fatal("this program must be started by hakurei") } else { toolPath = p diff --git a/cmd/hsu/package.nix b/cmd/hsu/package.nix index 5fce566..6075cdb 100644 --- a/cmd/hsu/package.nix +++ b/cmd/hsu/package.nix @@ -19,5 +19,5 @@ buildGoModule { ldflags = lib.attrsets.foldlAttrs ( ldflags: name: value: ldflags ++ [ "-X main.${name}=${value}" ] - ) [ "-s -w" ] { hmain = "${hakurei}/libexec/hakurei"; }; + ) [ "-s -w" ] { hakureiPath = "${hakurei}/libexec/hakurei"; }; } diff --git a/cmd/hsu/path.go b/cmd/hsu/path.go deleted file mode 100644 index 53aa9d1..0000000 --- a/cmd/hsu/path.go +++ /dev/null @@ -1,20 +0,0 @@ -package main - -import ( - "log" - "path" -) - -const compPoison = "INVALIDINVALIDINVALIDINVALIDINVALID" - -var ( - hmain = compPoison -) - -func mustCheckPath(p string) string { - if p != compPoison && p != "" && path.IsAbs(p) { - return p - } - log.Fatal("this program is compiled incorrectly") - return compPoison -} diff --git a/dist/release.sh b/dist/release.sh index f547de0..47b6fd0 100755 --- a/dist/release.sh +++ b/dist/release.sh @@ -10,10 +10,10 @@ cp -rv "dist/comp" "${out}" go generate ./... go build -trimpath -v -o "${out}/bin/" -ldflags "-s -w -buildid= -extldflags '-static' - -X hakurei.app/internal.version=${VERSION} - -X hakurei.app/internal.hmain=/usr/bin/hakurei - -X hakurei.app/internal.hsu=/usr/bin/hsu - -X main.hmain=/usr/bin/hakurei" ./... + -X hakurei.app/internal.buildVersion=${VERSION} + -X hakurei.app/internal.hakureiPath=/usr/bin/hakurei + -X hakurei.app/internal.hsuPath=/usr/bin/hsu + -X main.hakureiPath=/usr/bin/hakurei" ./... rm -f "./${out}.tar.gz" && tar -C dist -czf "${out}.tar.gz" "${pname}" rm -rf "./${out}" diff --git a/internal/comp.go b/internal/comp.go deleted file mode 100644 index 28ee622..0000000 --- a/internal/comp.go +++ /dev/null @@ -1,17 +0,0 @@ -package internal - -const compPoison = "INVALIDINVALIDINVALIDINVALIDINVALID" - -var ( - version = compPoison -) - -// checkComp validates string value set at compile time. -func checkComp(s string) (string, bool) { return s, s != compPoison && s != "" } - -func Version() string { - if v, ok := checkComp(version); ok { - return v - } - return "impure" -} diff --git a/internal/path.go b/internal/path.go index 888689f..85e93ea 100644 --- a/internal/path.go +++ b/internal/path.go @@ -6,20 +6,20 @@ import ( "hakurei.app/container/check" ) -var ( - hmain = compPoison - hsu = compPoison -) +// Absolute paths to the Hakurei installation. +// +// These are set by the linker. +var hakureiPath, hsuPath string -// MustHakureiPath returns the absolute path to hakurei, configured at compile time. -func MustHakureiPath() *check.Absolute { return mustCheckPath(log.Fatal, "hakurei", hmain) } +// MustHakureiPath returns the [check.Absolute] path to hakurei. +func MustHakureiPath() *check.Absolute { return mustCheckPath(log.Fatal, "hakurei", hakureiPath) } -// MustHsuPath returns the absolute path to hakurei, configured at compile time. -func MustHsuPath() *check.Absolute { return mustCheckPath(log.Fatal, "hsu", hsu) } +// MustHsuPath returns the [check.Absolute] to hsu. +func MustHsuPath() *check.Absolute { return mustCheckPath(log.Fatal, "hsu", hsuPath) } -// mustCheckPath checks a pathname against compPoison, then [container.NewAbs], calling fatal if either step fails. +// mustCheckPath checks a pathname to not be zero, then [check.NewAbs], calling fatal if either step fails. func mustCheckPath(fatal func(v ...any), name, pathname string) *check.Absolute { - if pathname != compPoison && pathname != "" { + if pathname != "" { if a, err := check.NewAbs(pathname); err != nil { fatal(err.Error()) return nil // unreachable diff --git a/internal/path_test.go b/internal/path_test.go index 5bcdd85..f670c78 100644 --- a/internal/path_test.go +++ b/internal/path_test.go @@ -15,7 +15,6 @@ func TestMustCheckPath(t *testing.T) { pathname string wantFatal string }{ - {"poison", compPoison, "invalid test path, this program is compiled incorrectly"}, {"zero", "", "invalid test path, this program is compiled incorrectly"}, {"not absolute", "\x00", `path "\x00" is not absolute`}, {"success", "/proc/nonexistent", ""}, diff --git a/internal/version.go b/internal/version.go new file mode 100644 index 0000000..5c67108 --- /dev/null +++ b/internal/version.go @@ -0,0 +1,19 @@ +package internal + +// FallbackVersion is returned when a version string was not set by the linker. +const FallbackVersion = "dirty" + +// buildVersion is the Hakurei tree's version string at build time. +// +// This is set by the linker. +var buildVersion string + +// Version returns the Hakurei tree's version string. +// It is either the value of the constant [FallbackVersion] or, +// when possible, a release tag like "v1.0.0". +func Version() string { + if buildVersion != "" { + return buildVersion + } + return FallbackVersion +} diff --git a/package.nix b/package.nix index b6b06df..c27732c 100644 --- a/package.nix +++ b/package.nix @@ -75,9 +75,9 @@ buildGoModule rec { ] ) { - version = "v${version}"; - hmain = "${placeholder "out"}/libexec/hakurei"; - hsu = "/run/wrappers/bin/hsu"; + buildVersion = "v${version}"; + hakureiPath = "${placeholder "out"}/libexec/hakurei"; + hsuPath = "/run/wrappers/bin/hsu"; }; # nix build environment does not allow acls