mirror of https://github.com/docker/buildx.git
162 lines
3.5 KiB
Go
162 lines
3.5 KiB
Go
package storeutil
|
|
|
|
import (
|
|
"bytes"
|
|
"os"
|
|
"strings"
|
|
|
|
"github.com/docker/buildx/store"
|
|
"github.com/docker/buildx/util/confutil"
|
|
"github.com/docker/buildx/util/dockerutil"
|
|
"github.com/docker/buildx/util/imagetools"
|
|
"github.com/docker/buildx/util/resolver"
|
|
"github.com/docker/cli/cli/command"
|
|
buildkitdconfig "github.com/moby/buildkit/cmd/buildkitd/config"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
// GetStore returns current builder instance store
|
|
func GetStore(dockerCli command.Cli) (*store.Txn, func(), error) {
|
|
s, err := store.New(confutil.NewConfig(dockerCli))
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
return s.Txn()
|
|
}
|
|
|
|
func GetProxyConfig(dockerCli command.Cli) map[string]string {
|
|
cfg := dockerCli.ConfigFile()
|
|
host := dockerCli.Client().DaemonHost()
|
|
|
|
proxy, ok := cfg.Proxies[host]
|
|
if !ok {
|
|
proxy = cfg.Proxies["default"]
|
|
}
|
|
|
|
m := map[string]string{}
|
|
|
|
if v := proxy.HTTPProxy; v != "" {
|
|
m["HTTP_PROXY"] = v
|
|
}
|
|
if v := proxy.HTTPSProxy; v != "" {
|
|
m["HTTPS_PROXY"] = v
|
|
}
|
|
if v := proxy.NoProxy; v != "" {
|
|
m["NO_PROXY"] = v
|
|
}
|
|
if v := proxy.FTPProxy; v != "" {
|
|
m["FTP_PROXY"] = v
|
|
}
|
|
return m
|
|
}
|
|
|
|
// GetCurrentInstance finds the current builder instance
|
|
func GetCurrentInstance(txn *store.Txn, dockerCli command.Cli) (*store.NodeGroup, error) {
|
|
ep, err := dockerutil.GetCurrentEndpoint(dockerCli)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ng, err := txn.Current(ep)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if ng == nil {
|
|
ng, err = GetNodeGroup(txn, dockerCli, dockerCli.CurrentContext())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return ng, nil
|
|
}
|
|
|
|
// GetNodeGroup returns nodegroup based on the name
|
|
func GetNodeGroup(txn *store.Txn, dockerCli command.Cli, name string) (*store.NodeGroup, error) {
|
|
ng, err := txn.NodeGroupByName(name)
|
|
if err != nil {
|
|
if !os.IsNotExist(errors.Cause(err)) && !store.IsErrInvalidName(err) {
|
|
return nil, err
|
|
}
|
|
}
|
|
if ng != nil {
|
|
return ng, nil
|
|
}
|
|
|
|
list, err := dockerCli.ContextStore().List()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, l := range list {
|
|
if l.Name == name {
|
|
ng = &store.NodeGroup{
|
|
Name: name,
|
|
Nodes: []store.Node{
|
|
{
|
|
Name: name,
|
|
Endpoint: name,
|
|
},
|
|
},
|
|
DockerContext: true,
|
|
}
|
|
if ng.LastActivity, err = txn.GetLastActivity(ng); err != nil {
|
|
return nil, err
|
|
}
|
|
return ng, nil
|
|
}
|
|
}
|
|
|
|
return nil, errors.Errorf("no builder %q found", name)
|
|
}
|
|
|
|
func GetImageConfig(dockerCli command.Cli, ng *store.NodeGroup) (opt imagetools.Opt, err error) {
|
|
opt.Auth = dockerCli.ConfigFile()
|
|
|
|
if ng == nil || len(ng.Nodes) == 0 {
|
|
return opt, nil
|
|
}
|
|
|
|
files := ng.Nodes[0].Files
|
|
|
|
dt, ok := files["buildkitd.toml"]
|
|
if !ok {
|
|
return opt, nil
|
|
}
|
|
|
|
config, err := buildkitdconfig.Load(bytes.NewReader(dt))
|
|
if err != nil {
|
|
return opt, err
|
|
}
|
|
|
|
regconfig := make(map[string]resolver.RegistryConfig)
|
|
|
|
for k, v := range config.Registries {
|
|
rc := resolver.RegistryConfig{
|
|
Mirrors: v.Mirrors,
|
|
PlainHTTP: v.PlainHTTP,
|
|
Insecure: v.Insecure,
|
|
}
|
|
for _, ca := range v.RootCAs {
|
|
dt, ok := files[strings.TrimPrefix(ca, confutil.DefaultBuildKitConfigDir+"/")]
|
|
if ok {
|
|
rc.RootCAs = append(rc.RootCAs, dt)
|
|
}
|
|
}
|
|
|
|
for _, kp := range v.KeyPairs {
|
|
key, keyok := files[strings.TrimPrefix(kp.Key, confutil.DefaultBuildKitConfigDir+"/")]
|
|
cert, certok := files[strings.TrimPrefix(kp.Certificate, confutil.DefaultBuildKitConfigDir+"/")]
|
|
if keyok && certok {
|
|
rc.KeyPairs = append(rc.KeyPairs, resolver.TLSKeyPair{
|
|
Key: key,
|
|
Certificate: cert,
|
|
})
|
|
}
|
|
}
|
|
regconfig[k] = rc
|
|
}
|
|
|
|
opt.RegistryConfig = regconfig
|
|
|
|
return opt, nil
|
|
}
|