26c144c916
This brings over the initial buildx prototype from pulumi/pulumi-docker and fixes various build and release issues.
118 lines
2.8 KiB
Go
118 lines
2.8 KiB
Go
// Copyright 2024, Pulumi Corporation.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package internal
|
|
|
|
import (
|
|
"fmt"
|
|
)
|
|
|
|
// keeper decides whether an element should be included for a preview
|
|
// operation, optionally returning a mutated copy of that element.
|
|
type keeper[T any] interface {
|
|
keep(T) bool
|
|
}
|
|
|
|
// filter applies a keeper to each element, returning a new slice.
|
|
func filter[T any](k keeper[T], elems ...T) []T {
|
|
if elems == nil {
|
|
return nil
|
|
}
|
|
result := make([]T, 0, len(elems))
|
|
for _, e := range elems {
|
|
if !k.keep(e) {
|
|
continue
|
|
}
|
|
result = append(result, e)
|
|
}
|
|
return result
|
|
}
|
|
|
|
// stringKeeper preserves any non-empty string values for preview.
|
|
type stringKeeper struct{ preview bool }
|
|
|
|
func (k stringKeeper) keep(s string) bool {
|
|
if !k.preview {
|
|
return true
|
|
}
|
|
return s != ""
|
|
}
|
|
|
|
//nolint:structcheck // False positive due to generics.
|
|
type stringerKeeper[T fmt.Stringer] struct{ preview bool }
|
|
|
|
//nolint:unused // False positive due to generics.
|
|
func (k stringerKeeper[T]) keep(t T) bool {
|
|
if !k.preview {
|
|
return true
|
|
}
|
|
return stringKeeper(k).keep(t.String())
|
|
}
|
|
|
|
// registryKeeper preserves any registries with known values for address and
|
|
// password. This is imprecise and doesn't permit alternative auth strategies
|
|
// like registry tokens, email, etc.
|
|
type registryKeeper struct{ preview bool }
|
|
|
|
//nolint:unused // False positive due to generics.
|
|
func (k registryKeeper) keep(r Registry) bool {
|
|
if !k.preview {
|
|
return true
|
|
}
|
|
return r.Password != "" && r.Address != ""
|
|
}
|
|
|
|
// mapKeeper preserves map elements with known keys and values.
|
|
type mapKeeper struct{ preview bool }
|
|
|
|
func (k mapKeeper) keep(m map[string]string) map[string]string {
|
|
if !k.preview || len(m) == 0 {
|
|
return m
|
|
}
|
|
kk := stringKeeper(k)
|
|
filtered := make(map[string]string)
|
|
for key, val := range m {
|
|
if !kk.keep(key) {
|
|
continue
|
|
}
|
|
if !kk.keep(val) {
|
|
continue
|
|
}
|
|
filtered[key] = val
|
|
}
|
|
return filtered
|
|
}
|
|
|
|
type contextKeeper struct{ preview bool }
|
|
|
|
func (k contextKeeper) keep(bc *BuildContext) *BuildContext {
|
|
if !k.preview || bc == nil || len(bc.Named) == 0 {
|
|
return bc
|
|
}
|
|
|
|
named := NamedContexts{}
|
|
sk := stringKeeper(k)
|
|
for k, v := range bc.Named {
|
|
if !sk.keep(k) || !sk.keep(v.Location) {
|
|
continue
|
|
}
|
|
named[k] = v
|
|
}
|
|
|
|
return &BuildContext{
|
|
Context: Context{bc.Location},
|
|
Named: named,
|
|
}
|
|
}
|