Closed
Labels
FixPendingIssues that have a fix which has not yet been reviewed or submitted.Issues that have a fix which has not yet been reviewed or submitted.FrozenDueToAgeProposalProposal-Accepted
Milestone
Description
The runtime.GOROOT() function is currently implemented as follows:
- If the
GOROOTenvironment variable is set, return its value. - Else, return the value that was burned into the binary at compile time.
Unfortunately, this implementation cannot be relied upon to have any semantic meaning in general.
If the intent is to know what GOROOT the binary was compiled with, then consulting the GOROOT environment variable is wrong. Instead, the burned in value should be added to debug.BuildInfo.
If the intent is to know the GOROOT on the current machine, then consulting the burned in value is wrong, as it cannot handle the following (non-exhaustive) scenarios:
- The binary may have been compiled on another machine, with a totally irrelevant
GOROOT. - The go installation may have been moved since the binary was compiled.
- The
PATHenvironment variable may have changed since the binary was compiled. - The current machine might not even have a go installation.
Instead, the go env GOROOT command should be used. In particular, this change needs to be made for go/build.Default to function properly in all cases.
Reacted by Daniel Martí, Dominik Honnef, antichris, Bryan C. Mills, 0000 1000 1101 0010, Aerix, 李晓辉, Mauro Toffanin, Will Faught, Timo Friedl and 6 more
Reacted by Aram Hăvărneanu and as
Reacted by DeedleFake, Beoran and Luflosi
Metadata
Metadata
Assignees
Labels
FixPendingIssues that have a fix which has not yet been reviewed or submitted.Issues that have a fix which has not yet been reviewed or submitted.FrozenDueToAgeProposalProposal-Accepted
Activity
mvdan commentedon Mar 4, 2022
I think this is an interesting proposal, and I agree with the current confusion causing problems at times.
I assume that, if a program wants to try both approaches, they could have code that first tries one approach (like
go env GOROOT), and then falls back to the other (likedebug.BuildInfo).mvdan commentedon Mar 4, 2022
I fully agree with your suggestion to use
go env GOROOT, but I'm worried about changinggo/build.Default.GOROOT. Note thatDefaultis filled at init time, so it has a noticeable flat cost added to any program that ends up importing the package. Most of that cost currently comes from many calls toos.Getenv; adding an execution ofgo envwould make it significantly slower, making many Go programs take a few milliseconds longer to start.So when it comes to
go/build, I think we should either keep it as-is with a warning in its documentation, or fully deprecate theContext.GOROOTfield, instead pointing people to better alternatives likego env GOROOTto just query that one field, or to https://pkg.go.dev/golang.org/x/tools/go/packages for a whole-sale replacement of theContext.ImportAPI.rittneje commentedon Mar 4, 2022
One possible solution would be to add a private flag to
go/build.Context, such asisDefault bool. If true, then it won't set any environment variables when callinggo list, since at best this accomplishes nothing, and at worst causes bugs.go/src/go/build/build.go
Lines 1182 to 1188 in 81767e2
mvdan commentedon Mar 4, 2022
Would that help with the added init cost, though, if its init func may still call
go list?rittneje commentedon Mar 4, 2022
@mvdan I'm not suggesting that the init func for go/build call
go list. I'm saying that when go/build callsgo listwithinimportGo(which already happens today), it should not attempt to set any of the environment variables in the case ofbuild.Default.Alternatively, at the top of
importGo, it should callgo env GOROOTrather than relying on the (possibly broken) value ofbuild.Default.GOROOT.mvdan commentedon Mar 4, 2022
Ah, I see. I was thinking mainly of end users directly reading
build.Default.GOROOT. Presumably we need to do something about that one way or another.bcmills commentedon Mar 4, 2022
The one case I can think of where
runtime.GOROOT()may still be helpful is for tests, where it may be easier to invokeruntime.GOROOT()than to shell out togo env GOROOT. The latter may not be accurate anyway if thegoin$PATHis not the one used to compile the test. (Consider~/go-devel/bin/go test ., where~/go-develis aGOROOTbut is not listed in$PATH.)At least in principle, it is possible for the
gocommand to ensure thatGOROOTis set accurately in the test process's environment when it is run. Then again, if we do that then the test could runos.Getenv("GOROOT")just as easily asruntime.GOROOT(). 🤔rittneje commentedon Mar 4, 2022
@bcmills I'm not sure what the use cases are for looking up
GOROOTwhile unit testing, but one thing to keep in mind is that it is possible to compile a test binary with-cand then run it later. Consequently, it would run into the same general issues I mentioned above.bcmills commentedon Mar 4, 2022
That's true, but if you compile a test binary with
-cand then run it later, you are also responsible for replicating any conditions necessary for the test to succeed (working directory, environment, etc.).Even so, I suspect that most tests that depend on
runtime.GOROOT()only do so viago/build(for example, because they are testing analyzers for Go source code), and fixing #51483 would make those tests more robust either way.rittneje commentedon Mar 4, 2022
Gotcha. Actually, as an optimization, since we know that
$GOROOTtakes precedence if it's set, then go/build can just check the env var first before shelling out togo env GOROOT. Then maybe such test cases can mandate the env var gets set for stabler results (as in the example you mentioned).I guess another approach would be to have
go testmanipulate thePATHvariable for the sub-process, by prefixing it with$(go env GOROOT)/bin. Not sure if that would be too surprising, but it does have the nice side effect of ensuring that anygocommands that get spawned by the test do the more expected thing.rsc commentedon Mar 16, 2022
This proposal has been added to the active column of the proposals project
and will now be reviewed at the weekly proposal review meetings.
— rsc for the proposal review group
rsc commentedon Mar 23, 2022
@bradfitz reports that he has uses of runtime.GOROOT in GitHub actions where built binaries want to find the toolchain that built them, so they can invoke it to do other things.
It seems like we probably need to enumerate the uses people have for runtime.GOROOT and what they should do instead. It doesn't help to just say "Deprecated". We have to say what to use instead.
bradfitz commentedon Mar 23, 2022
For example:
63 remaining items
rittneje commentedon Nov 22, 2024
@willfaught See @ianlancetaylor's comment above, and burrowers/garble#878.
mvdan commentedon Nov 23, 2024
For environments where
go env GOROOTwill fail because Go is not installed, that's fine - we can skip loading tzdata from GOROOT just like we currently do when the embedded GOROOT path does not actually exist on disk. Why is that a problem? We already have other parts of the standard library which executego envfor similar purposes.Personally I would prefer if we nudged everyone towards https://pkg.go.dev/time/tzdata in the longer term, but assuming that we want to preserve the current zip loading logic from GOROOT, I think we should switch it to
go env GOROOTthe sooner the better.I would also not be surprised by this either, but I think those users would continue to be satisfied by the switch to
go env GOROOT.rittneje commentedon Nov 24, 2024
@mvdan Today I can compile an application that calls
time.LoadLocationfor Windows, put it on a Windows machine, set$GOROOT, and arrange for$GOROOT/lib/time/zoneinfo.zipto exist, without any need to install a Go toolchain on that Windows machine. Therefore changingtime.LoadLocationto invokego env GOROOTwould be a breaking change.DeedleFake commentedon Nov 24, 2024
Proposal for a proposal: Add
runtime/envto exposego env's lookup functionality programmatically, updatinggo envto use the new package itself for consistency. Then just use that to find the equivalent$(go env GOROOT)intime.LoadLocation().mvdan commentedon Nov 24, 2024
@rittneje fair enough, but that has nothing to do with the embedded GOROOT value. The logic could be to query the GOROOT env var first, and if empty, fall back to
go env GOROOT.@DeedleFake that is a separate proposal so it's best to not mix the two.
rittneje commentedon Nov 24, 2024
@mvdan Let's say I have Windows machine with Go installed at C:\Go. I then use that to compile my application (without
-trimpath), copy it to a second Windows machine, and arrange for C:\Go\lib\time\zoneinfo.zip to exist on the second machine. Today that will work. But usingos.Getenv("GOROOT")won't work (because the second machine never set that env var), nor will runninggo env GOROOT(because the second machine does not have a Go installation).@DeedleFake This can already be achieved in practice via
os.Getenv("GOROOT")followed byexec.LookPath("go"). Unfortunately, it does not address this backwards compatibility issue, because in the absence of theGOROOTenv var,runtime.GOROOT()returns the burned in GOROOT, not the Go installation.mvdan commentedon Nov 24, 2024
@rittneje that seems to me like a rare use case which relies on the embedded path, which is now being discouraged via this deprecation. I'm not arguing we need to break it right away, and it could be a phased approach via a GODEBUG, but I definitely think we need to stop supporting such a use case.
ianlancetaylor commentedon Nov 25, 2024
If we are going to keep checking
runtime.GOROOT, then are there really that many cases whereruntime.GOROOTfails butgo env GOROOTsucceeds?rittneje commentedon Nov 25, 2024
@ianlancetaylor I'm not sure what you mean by "keep checking
runtime.GOROOT". When$GOROOTis not set,runtime.GOROOT()andgo env GOROOTanswer completely different questions:runtime.GOROOT()gives the Go installation that compiled the application, possibly on another machine. And if you do-trimpath, then it yields the empty string.go env GOROOTgives the current Go installation on this machine, assuming it has one at all.In my view, as the documentation for
time.LoadLocationonly mentions$GOROOTand not anything about it trying to find "the current Go installation", runninggo env GOROOTas a fallback is not necessary. The only question is whether we need to account for the possibility that people have been relying on it falling back to the burned in GOROOT when$GOROOTis not set, even though the documentation does not mention this.In short, there are really three choices:
time.LoadLocationto useos.Getenv("GOROOT")instead ofruntime.GOROOT().godebugsetting to opt into or out of (2).aarzilli commentedon Nov 25, 2024
Using
go env GOROOTinstead ofruntime.GOROOThas potentially surprising implications now that ~everyone has multiple toolchains installed.ianlancetaylor commentedon Nov 25, 2024
@rittneje For your point 2, the
runtime.GOROOTfunction will already return the environment if it is set. If the environment variable is not set, it will return the value from the tools used to build the program. If we're OK with checking the environment variable, then I think the only question is whether it is harmful to also check the value from the tools.rittneje commentedon Nov 25, 2024
@ianlancetaylor I do not personally believe it is actively harmful for
time.LoadLocationto fall back to the burned in GOROOT. I do however thing it is surprising, given that it is not documented.Meanwhile, if someone really wants to augment
time.LoadLocationto try to find the Go installation instead of using the burned in GOROOT, that ought to be its own proposal.