mirror of https://github.com/linkerd/linkerd2.git
354 lines
12 KiB
Go
354 lines
12 KiB
Go
package inject
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/linkerd/linkerd2/controller/gen/config"
|
|
"github.com/linkerd/linkerd2/pkg/charts"
|
|
"github.com/linkerd/linkerd2/pkg/k8s"
|
|
"github.com/linkerd/linkerd2/pkg/version"
|
|
appsv1 "k8s.io/api/apps/v1"
|
|
corev1 "k8s.io/api/core/v1"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"sigs.k8s.io/yaml"
|
|
)
|
|
|
|
type expectedProxyConfigs struct {
|
|
identityContext *config.IdentityContext
|
|
image string
|
|
imagePullPolicy string
|
|
proxyVersion string
|
|
controlPort int32
|
|
inboundPort int32
|
|
adminPort int32
|
|
outboundPort int32
|
|
logLevel string
|
|
resourceRequirements *charts.Resources
|
|
proxyUID int64
|
|
initImage string
|
|
initImagePullPolicy string
|
|
initVersion string
|
|
inboundSkipPorts string
|
|
outboundSkipPorts string
|
|
}
|
|
|
|
func TestConfigAccessors(t *testing.T) {
|
|
// this test uses an annotated deployment and a proxyConfig object to verify
|
|
// all the proxy config accessors. The first test suite ensures that the
|
|
// accessors picks up the pod-level config annotations. The second test suite
|
|
// ensures that the defaults in the config map is used.
|
|
|
|
var (
|
|
controlPlaneVersion = "control-plane-version"
|
|
proxyVersion = "proxy-version"
|
|
proxyVersionOverride = "proxy-version-override"
|
|
)
|
|
|
|
proxyConfig := &config.Proxy{
|
|
ProxyImage: &config.Image{ImageName: "gcr.io/linkerd-io/proxy", PullPolicy: "IfNotPresent"},
|
|
ProxyInitImage: &config.Image{ImageName: "gcr.io/linkerd-io/proxy-init", PullPolicy: "IfNotPresent"},
|
|
ControlPort: &config.Port{Port: 9000},
|
|
InboundPort: &config.Port{Port: 6000},
|
|
AdminPort: &config.Port{Port: 6001},
|
|
OutboundPort: &config.Port{Port: 6002},
|
|
IgnoreInboundPorts: []*config.Port{{Port: 53}},
|
|
IgnoreOutboundPorts: []*config.Port{{Port: 9079}},
|
|
Resource: &config.ResourceRequirements{
|
|
RequestCpu: "0.2",
|
|
RequestMemory: "64",
|
|
LimitCpu: "1",
|
|
LimitMemory: "128",
|
|
},
|
|
ProxyUid: 8888,
|
|
LogLevel: &config.LogLevel{Level: "info,linkerd2_proxy=debug"},
|
|
DisableExternalProfiles: false,
|
|
ProxyVersion: proxyVersion,
|
|
}
|
|
|
|
globalConfig := &config.Global{
|
|
LinkerdNamespace: "linkerd",
|
|
Version: controlPlaneVersion,
|
|
IdentityContext: &config.IdentityContext{},
|
|
ClusterDomain: "cluster.local",
|
|
}
|
|
|
|
configs := &config.All{Global: globalConfig, Proxy: proxyConfig}
|
|
|
|
var testCases = []struct {
|
|
id string
|
|
nsAnnotations map[string]string
|
|
spec appsv1.DeploymentSpec
|
|
expected expectedProxyConfigs
|
|
}{
|
|
{id: "use overrides",
|
|
spec: appsv1.DeploymentSpec{
|
|
Template: corev1.PodTemplateSpec{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Annotations: map[string]string{
|
|
k8s.ProxyDisableIdentityAnnotation: "true",
|
|
k8s.ProxyImageAnnotation: "gcr.io/linkerd-io/proxy",
|
|
k8s.ProxyImagePullPolicyAnnotation: "Always",
|
|
k8s.ProxyInitImageAnnotation: "gcr.io/linkerd-io/proxy-init",
|
|
k8s.ProxyControlPortAnnotation: "4000",
|
|
k8s.ProxyInboundPortAnnotation: "5000",
|
|
k8s.ProxyAdminPortAnnotation: "5001",
|
|
k8s.ProxyOutboundPortAnnotation: "5002",
|
|
k8s.ProxyIgnoreInboundPortsAnnotation: "4222,6222",
|
|
k8s.ProxyIgnoreOutboundPortsAnnotation: "8079,8080",
|
|
k8s.ProxyCPURequestAnnotation: "0.15",
|
|
k8s.ProxyMemoryRequestAnnotation: "120",
|
|
k8s.ProxyCPULimitAnnotation: "1.5",
|
|
k8s.ProxyMemoryLimitAnnotation: "256",
|
|
k8s.ProxyUIDAnnotation: "8500",
|
|
k8s.ProxyLogLevelAnnotation: "debug,linkerd2_proxy=debug",
|
|
k8s.ProxyEnableExternalProfilesAnnotation: "false",
|
|
k8s.ProxyVersionOverrideAnnotation: proxyVersionOverride},
|
|
},
|
|
Spec: corev1.PodSpec{},
|
|
},
|
|
},
|
|
expected: expectedProxyConfigs{
|
|
image: "gcr.io/linkerd-io/proxy",
|
|
imagePullPolicy: "Always",
|
|
proxyVersion: proxyVersionOverride,
|
|
controlPort: int32(4000),
|
|
inboundPort: int32(5000),
|
|
adminPort: int32(5001),
|
|
outboundPort: int32(5002),
|
|
logLevel: "debug,linkerd2_proxy=debug",
|
|
resourceRequirements: &charts.Resources{
|
|
CPU: charts.Constraints{
|
|
Limit: "1500m",
|
|
Request: "150m",
|
|
},
|
|
Memory: charts.Constraints{
|
|
Limit: "256",
|
|
Request: "120",
|
|
},
|
|
},
|
|
proxyUID: int64(8500),
|
|
initImage: "gcr.io/linkerd-io/proxy-init",
|
|
initImagePullPolicy: "Always",
|
|
initVersion: version.ProxyInitVersion,
|
|
inboundSkipPorts: "4222,6222",
|
|
outboundSkipPorts: "8079,8080",
|
|
},
|
|
},
|
|
{id: "use defaults",
|
|
spec: appsv1.DeploymentSpec{
|
|
Template: corev1.PodTemplateSpec{
|
|
ObjectMeta: metav1.ObjectMeta{},
|
|
Spec: corev1.PodSpec{},
|
|
},
|
|
},
|
|
expected: expectedProxyConfigs{
|
|
identityContext: &config.IdentityContext{},
|
|
image: "gcr.io/linkerd-io/proxy",
|
|
imagePullPolicy: "IfNotPresent",
|
|
proxyVersion: proxyVersion,
|
|
controlPort: int32(9000),
|
|
inboundPort: int32(6000),
|
|
adminPort: int32(6001),
|
|
outboundPort: int32(6002),
|
|
logLevel: "info,linkerd2_proxy=debug",
|
|
resourceRequirements: &charts.Resources{
|
|
CPU: charts.Constraints{
|
|
Limit: "1",
|
|
Request: "200m",
|
|
},
|
|
Memory: charts.Constraints{
|
|
Limit: "128",
|
|
Request: "64",
|
|
},
|
|
},
|
|
proxyUID: int64(8888),
|
|
initImage: "gcr.io/linkerd-io/proxy-init",
|
|
initImagePullPolicy: "IfNotPresent",
|
|
initVersion: version.ProxyInitVersion,
|
|
inboundSkipPorts: "53",
|
|
outboundSkipPorts: "9079",
|
|
},
|
|
},
|
|
{id: "use namespace overrides",
|
|
nsAnnotations: map[string]string{
|
|
k8s.ProxyDisableIdentityAnnotation: "true",
|
|
k8s.ProxyImageAnnotation: "gcr.io/linkerd-io/proxy",
|
|
k8s.ProxyImagePullPolicyAnnotation: "Always",
|
|
k8s.ProxyInitImageAnnotation: "gcr.io/linkerd-io/proxy-init",
|
|
k8s.ProxyControlPortAnnotation: "4000",
|
|
k8s.ProxyInboundPortAnnotation: "5000",
|
|
k8s.ProxyAdminPortAnnotation: "5001",
|
|
k8s.ProxyOutboundPortAnnotation: "5002",
|
|
k8s.ProxyIgnoreInboundPortsAnnotation: "4222,6222",
|
|
k8s.ProxyIgnoreOutboundPortsAnnotation: "8079,8080",
|
|
k8s.ProxyCPURequestAnnotation: "0.15",
|
|
k8s.ProxyMemoryRequestAnnotation: "120",
|
|
k8s.ProxyCPULimitAnnotation: "1.5",
|
|
k8s.ProxyMemoryLimitAnnotation: "256",
|
|
k8s.ProxyUIDAnnotation: "8500",
|
|
k8s.ProxyLogLevelAnnotation: "debug,linkerd2_proxy=debug",
|
|
k8s.ProxyEnableExternalProfilesAnnotation: "false",
|
|
k8s.ProxyVersionOverrideAnnotation: proxyVersionOverride},
|
|
spec: appsv1.DeploymentSpec{
|
|
Template: corev1.PodTemplateSpec{
|
|
Spec: corev1.PodSpec{},
|
|
},
|
|
},
|
|
expected: expectedProxyConfigs{
|
|
image: "gcr.io/linkerd-io/proxy",
|
|
imagePullPolicy: "Always",
|
|
proxyVersion: proxyVersionOverride,
|
|
controlPort: int32(4000),
|
|
inboundPort: int32(5000),
|
|
adminPort: int32(5001),
|
|
outboundPort: int32(5002),
|
|
logLevel: "debug,linkerd2_proxy=debug",
|
|
resourceRequirements: &charts.Resources{
|
|
CPU: charts.Constraints{
|
|
Limit: "1500m",
|
|
Request: "150m",
|
|
},
|
|
Memory: charts.Constraints{
|
|
Limit: "256",
|
|
Request: "120",
|
|
},
|
|
},
|
|
proxyUID: int64(8500),
|
|
initImage: "gcr.io/linkerd-io/proxy-init",
|
|
initImagePullPolicy: "Always",
|
|
initVersion: version.ProxyInitVersion,
|
|
inboundSkipPorts: "4222,6222",
|
|
outboundSkipPorts: "8079,8080",
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
testCase := tc
|
|
t.Run(testCase.id, func(t *testing.T) {
|
|
data, err := yaml.Marshal(&appsv1.Deployment{Spec: testCase.spec})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
resourceConfig := NewResourceConfig(configs, OriginUnknown).WithKind("Deployment").WithNsAnnotations(testCase.nsAnnotations)
|
|
if err := resourceConfig.parse(data); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
t.Run("identityContext", func(t *testing.T) {
|
|
expected := testCase.expected.identityContext
|
|
if actual := resourceConfig.identityContext(); !reflect.DeepEqual(expected, actual) {
|
|
t.Errorf("Expected: %+v Actual: %+v", expected, actual)
|
|
}
|
|
})
|
|
|
|
t.Run("proxyImage", func(t *testing.T) {
|
|
expected := testCase.expected.image
|
|
if actual := resourceConfig.proxyImage(); expected != actual {
|
|
t.Errorf("Expected: %v Actual: %v", expected, actual)
|
|
}
|
|
})
|
|
|
|
t.Run("proxyImagePullPolicy", func(t *testing.T) {
|
|
expected := testCase.expected.imagePullPolicy
|
|
if actual := resourceConfig.proxyImagePullPolicy(); expected != actual {
|
|
t.Errorf("Expected: %v Actual: %v", expected, actual)
|
|
}
|
|
})
|
|
|
|
t.Run("proxyVersion", func(t *testing.T) {
|
|
expected := testCase.expected.proxyVersion
|
|
if actual := resourceConfig.proxyVersion(); expected != actual {
|
|
t.Errorf("Expected: %v Actual: %v", expected, actual)
|
|
}
|
|
})
|
|
|
|
t.Run("proxyInitVersion", func(t *testing.T) {
|
|
expected := testCase.expected.initVersion
|
|
if actual := resourceConfig.proxyInitVersion(); expected != actual {
|
|
t.Errorf("Expected: %v Actual: %v", expected, actual)
|
|
}
|
|
})
|
|
|
|
t.Run("proxyControlPort", func(t *testing.T) {
|
|
expected := testCase.expected.controlPort
|
|
if actual := resourceConfig.proxyControlPort(); expected != actual {
|
|
t.Errorf("Expected: %v Actual: %v", expected, actual)
|
|
}
|
|
})
|
|
|
|
t.Run("proxyInboundPort", func(t *testing.T) {
|
|
expected := testCase.expected.inboundPort
|
|
if actual := resourceConfig.proxyInboundPort(); expected != actual {
|
|
t.Errorf("Expected: %v Actual: %v", expected, actual)
|
|
}
|
|
})
|
|
|
|
t.Run("proxyAdminPort", func(t *testing.T) {
|
|
expected := testCase.expected.adminPort
|
|
if actual := resourceConfig.proxyAdminPort(); expected != actual {
|
|
t.Errorf("Expected: %v Actual: %v", expected, actual)
|
|
}
|
|
})
|
|
|
|
t.Run("proxyOutboundPort", func(t *testing.T) {
|
|
expected := testCase.expected.outboundPort
|
|
if actual := resourceConfig.proxyOutboundPort(); expected != actual {
|
|
t.Errorf("Expected: %v Actual: %v", expected, actual)
|
|
}
|
|
})
|
|
|
|
t.Run("proxyLogLevel", func(t *testing.T) {
|
|
expected := testCase.expected.logLevel
|
|
if actual := resourceConfig.proxyLogLevel(); expected != actual {
|
|
t.Errorf("Expected: %v Actual: %v", expected, actual)
|
|
}
|
|
})
|
|
|
|
t.Run("proxyResourceRequirements", func(t *testing.T) {
|
|
expected := testCase.expected.resourceRequirements
|
|
if actual := resourceConfig.proxyResourceRequirements(); !reflect.DeepEqual(expected, actual) {
|
|
t.Errorf("Expected: %v Actual: %v", expected, actual)
|
|
}
|
|
})
|
|
|
|
t.Run("proxyUID", func(t *testing.T) {
|
|
expected := testCase.expected.proxyUID
|
|
if actual := resourceConfig.proxyUID(); expected != actual {
|
|
t.Errorf("Expected: %v Actual: %v", expected, actual)
|
|
}
|
|
})
|
|
|
|
t.Run("proxyInitImage", func(t *testing.T) {
|
|
expected := testCase.expected.initImage
|
|
if actual := resourceConfig.proxyInitImage(); expected != actual {
|
|
t.Errorf("Expected: %v Actual: %v", expected, actual)
|
|
}
|
|
})
|
|
|
|
t.Run("proxyInitImagePullPolicy", func(t *testing.T) {
|
|
expected := testCase.expected.initImagePullPolicy
|
|
if actual := resourceConfig.proxyInitImagePullPolicy(); expected != actual {
|
|
t.Errorf("Expected: %v Actual: %v", expected, actual)
|
|
}
|
|
})
|
|
|
|
t.Run("proxyInboundSkipPorts", func(t *testing.T) {
|
|
expected := testCase.expected.inboundSkipPorts
|
|
if actual := resourceConfig.proxyInboundSkipPorts(); expected != actual {
|
|
t.Errorf("Expected: %v Actual: %v", expected, actual)
|
|
}
|
|
})
|
|
|
|
t.Run("proxyOutboundSkipPorts", func(t *testing.T) {
|
|
expected := testCase.expected.outboundSkipPorts
|
|
if actual := resourceConfig.proxyOutboundSkipPorts(); expected != actual {
|
|
t.Errorf("Expected: %v Actual: %v", expected, actual)
|
|
}
|
|
})
|
|
})
|
|
}
|
|
}
|