mirror of
https://gitea.com/Lydanne/buildx.git
synced 2025-11-04 10:03:42 +08:00
6b65b0c982
Tested with `kind` and GKE. Note: "nodes" shown in `docker buildx ls` are unrelated to Kubernetes "nodes". Probably buildx should come up with an alternative term. Usage: $ kind create cluster $ export KUBECONFIG="$(kind get kubeconfig-path --name="kind")" $ docker buildx create --driver kubernetes --driver-opt replicas=3 --use $ docker buildx build -t foo --load . `--load` loads the image into the local Docker. Driver opts: - `image=IMAGE` - Sets the container image to be used for running buildkit. - `namespace=NS` - Sets the Kubernetes namespace. Defaults to the current namespace. - `replicas=N` - Sets the number of `Pod` replicas. Defaults to 1. - `rootless=(true|false)` - Run the container as a non-root user without `securityContext.privileged`. Defaults to false. - `loadbalance=(sticky|random)` - Load-balancing strategy. If set to "sticky", the pod is chosen using the hash of the context path. Defaults to "sticky" Signed-off-by: Akihiro Suda <akihiro.suda.cz@hco.ntt.co.jp>
111 lines
3.1 KiB
Go
111 lines
3.1 KiB
Go
// Copyright 2011 Google Inc. All rights reserved.
|
|
// Use of this source code is governed by the Apache 2.0
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// Package internal provides support for package appengine.
|
|
//
|
|
// Programs should not use this package directly. Its API is not stable.
|
|
// Use packages appengine and appengine/* instead.
|
|
package internal
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/golang/protobuf/proto"
|
|
|
|
remotepb "google.golang.org/appengine/internal/remote_api"
|
|
)
|
|
|
|
// errorCodeMaps is a map of service name to the error code map for the service.
|
|
var errorCodeMaps = make(map[string]map[int32]string)
|
|
|
|
// RegisterErrorCodeMap is called from API implementations to register their
|
|
// error code map. This should only be called from init functions.
|
|
func RegisterErrorCodeMap(service string, m map[int32]string) {
|
|
errorCodeMaps[service] = m
|
|
}
|
|
|
|
type timeoutCodeKey struct {
|
|
service string
|
|
code int32
|
|
}
|
|
|
|
// timeoutCodes is the set of service+code pairs that represent timeouts.
|
|
var timeoutCodes = make(map[timeoutCodeKey]bool)
|
|
|
|
func RegisterTimeoutErrorCode(service string, code int32) {
|
|
timeoutCodes[timeoutCodeKey{service, code}] = true
|
|
}
|
|
|
|
// APIError is the type returned by appengine.Context's Call method
|
|
// when an API call fails in an API-specific way. This may be, for instance,
|
|
// a taskqueue API call failing with TaskQueueServiceError::UNKNOWN_QUEUE.
|
|
type APIError struct {
|
|
Service string
|
|
Detail string
|
|
Code int32 // API-specific error code
|
|
}
|
|
|
|
func (e *APIError) Error() string {
|
|
if e.Code == 0 {
|
|
if e.Detail == "" {
|
|
return "APIError <empty>"
|
|
}
|
|
return e.Detail
|
|
}
|
|
s := fmt.Sprintf("API error %d", e.Code)
|
|
if m, ok := errorCodeMaps[e.Service]; ok {
|
|
s += " (" + e.Service + ": " + m[e.Code] + ")"
|
|
} else {
|
|
// Shouldn't happen, but provide a bit more detail if it does.
|
|
s = e.Service + " " + s
|
|
}
|
|
if e.Detail != "" {
|
|
s += ": " + e.Detail
|
|
}
|
|
return s
|
|
}
|
|
|
|
func (e *APIError) IsTimeout() bool {
|
|
return timeoutCodes[timeoutCodeKey{e.Service, e.Code}]
|
|
}
|
|
|
|
// CallError is the type returned by appengine.Context's Call method when an
|
|
// API call fails in a generic way, such as RpcError::CAPABILITY_DISABLED.
|
|
type CallError struct {
|
|
Detail string
|
|
Code int32
|
|
// TODO: Remove this if we get a distinguishable error code.
|
|
Timeout bool
|
|
}
|
|
|
|
func (e *CallError) Error() string {
|
|
var msg string
|
|
switch remotepb.RpcError_ErrorCode(e.Code) {
|
|
case remotepb.RpcError_UNKNOWN:
|
|
return e.Detail
|
|
case remotepb.RpcError_OVER_QUOTA:
|
|
msg = "Over quota"
|
|
case remotepb.RpcError_CAPABILITY_DISABLED:
|
|
msg = "Capability disabled"
|
|
case remotepb.RpcError_CANCELLED:
|
|
msg = "Canceled"
|
|
default:
|
|
msg = fmt.Sprintf("Call error %d", e.Code)
|
|
}
|
|
s := msg + ": " + e.Detail
|
|
if e.Timeout {
|
|
s += " (timeout)"
|
|
}
|
|
return s
|
|
}
|
|
|
|
func (e *CallError) IsTimeout() bool {
|
|
return e.Timeout
|
|
}
|
|
|
|
// NamespaceMods is a map from API service to a function that will mutate an RPC request to attach a namespace.
|
|
// The function should be prepared to be called on the same message more than once; it should only modify the
|
|
// RPC request the first time.
|
|
var NamespaceMods = make(map[string]func(m proto.Message, namespace string))
|