-
Notifications
You must be signed in to change notification settings - Fork 287
/
env.go
142 lines (118 loc) · 3.54 KB
/
env.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
package docker
import (
"context"
"fmt"
"os"
"github.com/docker/cli/opts"
"github.com/pkg/errors"
"github.com/windmilleng/tilt/internal/container"
"github.com/windmilleng/tilt/internal/k8s"
"github.com/windmilleng/tilt/internal/minikube"
)
// See notes on CreateClientOpts. These environment variables are standard docker env configs.
type Env struct {
Host string
APIVersion string
TLSVerify string
CertPath string
// Minikube's docker client has a bug where it can't use buildkit. See:
// https://github.com/kubernetes/minikube/issues/4143
IsMinikube bool
}
// Serializes this back to environment variables for os.Environ
func (e Env) AsEnviron() []string {
vars := []string{}
if e.Host != "" {
vars = append(vars, fmt.Sprintf("DOCKER_HOST=%s", e.Host))
}
if e.APIVersion != "" {
vars = append(vars, fmt.Sprintf("DOCKER_API_VERSION=%s", e.APIVersion))
}
if e.CertPath != "" {
vars = append(vars, fmt.Sprintf("DOCKER_CERT_PATH=%s", e.CertPath))
}
if e.TLSVerify != "" {
vars = append(vars, fmt.Sprintf("DOCKER_TLS_VERIFY=%s", e.TLSVerify))
}
return vars
}
// Tell wire to create two docker envs: one for the local CLI and one for the in-cluster CLI.
type ClusterEnv Env
type LocalEnv Env
func ProvideLocalEnv(ctx context.Context, cEnv ClusterEnv) (LocalEnv, error) {
result, err := overlayOSEnvVars(Env{})
if err != nil {
return LocalEnv{}, err
}
// The user may have already configured their local docker client
// to use Minikube's docker server. We check for that by comparing
// the hosts of the LocalEnv and ClusterEnv.
if cEnv.Host == result.Host {
result.IsMinikube = cEnv.IsMinikube
}
return LocalEnv(result), err
}
func ProvideClusterEnv(ctx context.Context, env k8s.Env, runtime container.Runtime, minikubeClient minikube.Client) (ClusterEnv, error) {
result := Env{}
if runtime == container.RuntimeDocker {
if env == k8s.EnvMinikube {
// If we're running Minikube with a docker runtime, talk to Minikube's docker socket.
envMap, err := minikubeClient.DockerEnv(ctx)
if err != nil {
return ClusterEnv{}, errors.Wrap(err, "ProvideDockerEnv")
}
host := envMap["DOCKER_HOST"]
if host != "" {
result.Host = host
}
apiVersion := envMap["DOCKER_API_VERSION"]
if apiVersion != "" {
result.APIVersion = apiVersion
}
certPath := envMap["DOCKER_CERT_PATH"]
if certPath != "" {
result.CertPath = certPath
}
tlsVerify := envMap["DOCKER_TLS_VERIFY"]
if tlsVerify != "" {
result.TLSVerify = tlsVerify
}
result.IsMinikube = true
} else if env == k8s.EnvMicroK8s {
// If we're running Microk8s with a docker runtime, talk to Microk8s's docker socket.
result.Host = microK8sDockerHost
}
}
resultEnv, err := overlayOSEnvVars(Env(result))
if err != nil {
return ClusterEnv{}, err
}
return ClusterEnv(resultEnv), nil
}
func overlayOSEnvVars(result Env) (Env, error) {
host := os.Getenv("DOCKER_HOST")
if host != "" {
host, err := opts.ParseHost(true, host)
if err != nil {
return Env{}, errors.Wrap(err, "ProvideDockerEnv")
}
// If the docker host is set from the env and different from the cluster host,
// ignore all the variables from minikube/microk8s
if host != result.Host {
result = Env{Host: host}
}
}
apiVersion := os.Getenv("DOCKER_API_VERSION")
if apiVersion != "" {
result.APIVersion = apiVersion
}
certPath := os.Getenv("DOCKER_CERT_PATH")
if certPath != "" {
result.CertPath = certPath
}
tlsVerify := os.Getenv("DOCKER_TLS_VERIFY")
if tlsVerify != "" {
result.TLSVerify = tlsVerify
}
return result, nil
}