Previously, we'd use the ctx from the Build invocation, but because
remote stashes the remote.WithContext option, when we later go to fetch
the actual base image to write it out to a tarball, it will fail because
the Build ctx was cancelled.
For whatever reason, NewGo takes a ctx, so this change propagates the
badness from remote so we can use the NewGo ctx when we fetch base
images.
* Build each platform concurrently
At least on my machine, this is slightly faster on a cold build and
saves significant time on a warm build.
* Plumb --jobs down to multi-arch
* Add deprecation warning for build.Limiter
This saves a roundtrip to the registry if we ever use the same base
image for multiple builds in a single invocation.
This also sets us up for using an on-disk cache for image metadata to
speed things up even further.
* Introduce KOCACHE
Cache binaries under $KOCACHE/<import path>/<platform>
Cache metdata mapping buildid to diffid and diffid to descriptor.
* Point TODO at issue
* Split layerCache into separate file
This makes things a little cleaner by having a single place that calls
buildLayer and passing a thunk down into the cache logic to call that on
a cache miss.
Also, remove the debug logging to make the code easier to follow (if you
need to recompile anyway, it's easy enough to add log lines).
* Move cached output to $KOCACHE/bin
This was using remote.WithTransport to set it manually, and this is much
simpler (also annotates with the go-containerregistry version). This is
really nice because it will give us at least some version information
where we had none before (for non-releases).
Before:
ko
ko/(devel)
ko/v0.7.0
After:
ko go-containerregistry/v0.4.0
ko/(devel) go-containerregistry/v0.4.0
ko/v0.7.0 go-containerregistry/v0.4.0
We dropped this flag, so we're always in non-strict mode by default,
so if there is a ko:// reference that fails to build, we don't error
out. This drops some guards so that we are always in strict mode and
only build ko:// things.
This was previously `ko auth login`, which I've hidden, and perhaps we
can alias to `ko login` in the future, but in theory folks could have
been using `ko auth get`, and I don't want to break that for no reason.
* Allow comma-separated list of platforms
* Parse platform spec once
* Update --platform docs in README
* Update pkg/build/gobuild_test.go
Co-authored-by: Matt Moore <mattmoor@vmware.com>
* Return err for bad defaulting for --platform
Also respect GOARM as variant if the goarch is arm.
* Refactor platform matching
* Update README.md to mention GOARM
* Fix travis test
Co-authored-by: Matt Moore <mattmoor@vmware.com>
* Add ctx to publish.Interface
I noticed that hitting ctrl-C didn't work when pushing images, this
should fix that.
* Use context everywhere that makes sense
* Create a MultiPublisher
MultiPublisher mimics io.MultiWriter in that it will publish an image to
multiple publish.Interface implementations.
* Add publish.{Tarball,Layout}Publisher
This adds support for publishing in the tarball format and to an OCI
image layout.
The tarball format isn't great, yet. It only supports writing once
instead of appending.
* Consolidate options
These were spread all over the place for no reasons. Now all the
publisher related options are grouped together.
* Add options for tarball/layout
Adds --oci-layout-path, --tarball, and --push flags.
--push=false will disable the default behavior of publishing to a
registry.
* go mod vendor
* Add Close method to publish.Interface
This allows us to defer writing to the tarball until we've collected all
the images that have been published.
* Fix tests
When resolving files, we would just log.Fatal if we encountered an
error. This seems to be racy and causes ko to exit with a 0 error code
when it shouldn't. To fix this, we synchronize the builder goroutines
with the kubectl go routine and exit with an error if either of them
failed.
This fix also happened to fix a goroutine leak. If the kubectl goroutine
failed, we never properly cancelled the builds, which would happily
conitnue compiling packages and consuming resources.
If a single tag is explicitly set (i.e. it's not "latest"), include that
in the reference that gets rendered in the yaml.
This is really useful for tracking releases.
* Add build.Limiter
You can limit the number of concurrent builds with -j (a la make).
The default value for this is GOMAXPROCS, which seems reasonable.
This hoists the publisher creation out of the loop for `ko publish` to
avoid needlessly resolving credentials multiple times.
This pulls the publisher creation outside of resolveFilesToWriter so we
can fail earlier if e.g. KO_DOCKER_REPO is unset, otherwise we start up
the kubectl goroutine and it would asynchronously fail with:
error: no objects passed to apply
jonjohnsonjr
