mirror of
https://github.com/vmware-tanzu/velero.git
synced 2026-02-05 19:40:49 +00:00
6745979a7b
* Wait for CRDs to be available and ready When restoring CRDs, we should wait for the definition to be ready and available before moving on to restoring specific CRs. While the CRDs are often ready by the time we get to restoring a CR, there is a race condition where the CRD isn't ready. This change waits on each CRD at restore time. Signed-off-by: Nolan Brubaker <brubakern@vmware.com>
338 lines
10 KiB
Go
338 lines
10 KiB
Go
/*
|
|
Copyright 2017 the Velero contributors.
|
|
|
|
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 kube
|
|
|
|
import (
|
|
"encoding/json"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/sirupsen/logrus"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
corev1 "k8s.io/api/core/v1"
|
|
apiextv1beta1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
|
|
k8serrors "k8s.io/apimachinery/pkg/api/errors"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
|
|
"k8s.io/apimachinery/pkg/runtime"
|
|
"k8s.io/apimachinery/pkg/runtime/schema"
|
|
kubeinformers "k8s.io/client-go/informers"
|
|
|
|
"github.com/vmware-tanzu/velero/pkg/builder"
|
|
"github.com/vmware-tanzu/velero/pkg/test"
|
|
velerotest "github.com/vmware-tanzu/velero/pkg/test"
|
|
)
|
|
|
|
func TestNamespaceAndName(t *testing.T) {
|
|
//TODO
|
|
}
|
|
|
|
func TestEnsureNamespaceExistsAndIsReady(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
expectNSFound bool
|
|
nsPhase corev1.NamespacePhase
|
|
nsDeleting bool
|
|
expectCreate bool
|
|
alreadyExists bool
|
|
expectedResult bool
|
|
}{
|
|
{
|
|
name: "namespace found, not deleting",
|
|
expectNSFound: true,
|
|
expectedResult: true,
|
|
},
|
|
{
|
|
name: "namespace found, terminating phase",
|
|
expectNSFound: true,
|
|
nsPhase: corev1.NamespaceTerminating,
|
|
expectedResult: false,
|
|
},
|
|
{
|
|
name: "namespace found, deletiontimestamp set",
|
|
expectNSFound: true,
|
|
nsDeleting: true,
|
|
expectedResult: false,
|
|
},
|
|
{
|
|
name: "namespace not found, successfully created",
|
|
expectCreate: true,
|
|
expectedResult: true,
|
|
},
|
|
{
|
|
name: "namespace not found initially, create returns already exists error, returned namespace is ready",
|
|
alreadyExists: true,
|
|
expectedResult: true,
|
|
},
|
|
{
|
|
name: "namespace not found initially, create returns already exists error, returned namespace is terminating",
|
|
alreadyExists: true,
|
|
nsPhase: corev1.NamespaceTerminating,
|
|
expectedResult: false,
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
namespace := &corev1.Namespace{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "test",
|
|
},
|
|
}
|
|
|
|
if test.nsPhase != "" {
|
|
namespace.Status.Phase = test.nsPhase
|
|
}
|
|
|
|
if test.nsDeleting {
|
|
namespace.SetDeletionTimestamp(&metav1.Time{Time: time.Now()})
|
|
}
|
|
|
|
timeout := time.Millisecond
|
|
|
|
nsClient := &velerotest.FakeNamespaceClient{}
|
|
defer nsClient.AssertExpectations(t)
|
|
|
|
if test.expectNSFound {
|
|
nsClient.On("Get", "test", metav1.GetOptions{}).Return(namespace, nil)
|
|
} else {
|
|
nsClient.On("Get", "test", metav1.GetOptions{}).Return(&corev1.Namespace{}, k8serrors.NewNotFound(schema.GroupResource{Resource: "namespaces"}, "test"))
|
|
}
|
|
|
|
if test.alreadyExists {
|
|
nsClient.On("Create", namespace).Return(namespace, k8serrors.NewAlreadyExists(schema.GroupResource{Resource: "namespaces"}, "test"))
|
|
}
|
|
|
|
if test.expectCreate {
|
|
nsClient.On("Create", namespace).Return(namespace, nil)
|
|
}
|
|
|
|
result, _ := EnsureNamespaceExistsAndIsReady(namespace, nsClient, timeout)
|
|
|
|
assert.Equal(t, test.expectedResult, result)
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
type harness struct {
|
|
*test.APIServer
|
|
|
|
log logrus.FieldLogger
|
|
}
|
|
|
|
func newHarness(t *testing.T) *harness {
|
|
t.Helper()
|
|
|
|
return &harness{
|
|
APIServer: test.NewAPIServer(t),
|
|
log: logrus.StandardLogger(),
|
|
}
|
|
}
|
|
|
|
// TestGetVolumeDirectorySuccess tests that the GetVolumeDirectory function
|
|
// returns a volume's name or a volume's name plus '/mount' when a PVC is present.
|
|
func TestGetVolumeDirectorySuccess(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
pod *corev1.Pod
|
|
pvc *corev1.PersistentVolumeClaim
|
|
pv *corev1.PersistentVolume
|
|
want string
|
|
}{
|
|
{
|
|
name: "Non-CSI volume with a PVC/PV returns the volume's name",
|
|
pod: builder.ForPod("ns-1", "my-pod").Volumes(builder.ForVolume("my-vol").PersistentVolumeClaimSource("my-pvc").Result()).Result(),
|
|
pvc: builder.ForPersistentVolumeClaim("ns-1", "my-pvc").VolumeName("a-pv").Result(),
|
|
pv: builder.ForPersistentVolume("a-pv").Result(),
|
|
want: "a-pv",
|
|
},
|
|
{
|
|
name: "CSI volume with a PVC/PV appends '/mount' to the volume name",
|
|
pod: builder.ForPod("ns-1", "my-pod").Volumes(builder.ForVolume("my-vol").PersistentVolumeClaimSource("my-pvc").Result()).Result(),
|
|
pvc: builder.ForPersistentVolumeClaim("ns-1", "my-pvc").VolumeName("a-pv").Result(),
|
|
pv: builder.ForPersistentVolume("a-pv").CSI("csi.test.com", "provider-volume-id").Result(),
|
|
want: "a-pv/mount",
|
|
},
|
|
{
|
|
name: "CSI volume mounted without a PVC appends '/mount' to the volume name",
|
|
pod: builder.ForPod("ns-1", "my-pod").Volumes(builder.ForVolume("my-vol").CSISource("csi.test.com").Result()).Result(),
|
|
want: "my-vol/mount",
|
|
},
|
|
{
|
|
name: "Non-CSI volume without a PVC returns the volume name",
|
|
pod: builder.ForPod("ns-1", "my-pod").Volumes(builder.ForVolume("my-vol").Result()).Result(),
|
|
want: "my-vol",
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
h := newHarness(t)
|
|
|
|
pvcInformer := kubeinformers.NewSharedInformerFactoryWithOptions(h.KubeClient, 0, kubeinformers.WithNamespace("ns-1")).Core().V1().PersistentVolumeClaims()
|
|
pvInformer := kubeinformers.NewSharedInformerFactory(h.KubeClient, 0).Core().V1().PersistentVolumes()
|
|
|
|
if tc.pvc != nil {
|
|
require.NoError(t, pvcInformer.Informer().GetStore().Add(tc.pvc))
|
|
}
|
|
if tc.pv != nil {
|
|
require.NoError(t, pvInformer.Informer().GetStore().Add(tc.pv))
|
|
}
|
|
|
|
// Function under test
|
|
dir, err := GetVolumeDirectory(tc.pod, tc.pod.Spec.Volumes[0].Name, pvcInformer.Lister(), pvInformer.Lister())
|
|
|
|
require.NoError(t, err)
|
|
assert.Equal(t, tc.want, dir)
|
|
}
|
|
}
|
|
|
|
func TestIsCRDReady(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
crd *apiextv1beta1.CustomResourceDefinition
|
|
want bool
|
|
}{
|
|
{
|
|
name: "CRD is not established & not accepting names - not ready",
|
|
crd: builder.ForCustomResourceDefinition("MyCRD").Result(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "CRD is established & not accepting names - not ready",
|
|
crd: builder.ForCustomResourceDefinition("MyCRD").
|
|
Condition(builder.ForCustomResourceDefinitionCondition().Type(apiextv1beta1.Established).Status(apiextv1beta1.ConditionTrue).Result()).Result(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "CRD is not established & accepting names - not ready",
|
|
crd: builder.ForCustomResourceDefinition("MyCRD").
|
|
Condition(builder.ForCustomResourceDefinitionCondition().Type(apiextv1beta1.NamesAccepted).Status(apiextv1beta1.ConditionTrue).Result()).Result(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "CRD is established & accepting names - ready",
|
|
crd: builder.ForCustomResourceDefinition("MyCRD").
|
|
Condition(builder.ForCustomResourceDefinitionCondition().Type(apiextv1beta1.Established).Status(apiextv1beta1.ConditionTrue).Result()).
|
|
Condition(builder.ForCustomResourceDefinitionCondition().Type(apiextv1beta1.NamesAccepted).Status(apiextv1beta1.ConditionTrue).Result()).
|
|
Result(),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
result := IsCRDReady(tc.crd)
|
|
assert.Equal(t, tc.want, result)
|
|
}
|
|
}
|
|
|
|
func TestIsUnstructuredCRDReady(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
crd *apiextv1beta1.CustomResourceDefinition
|
|
want bool
|
|
}{
|
|
{
|
|
name: "CRD is not established & not accepting names - not ready",
|
|
crd: builder.ForCustomResourceDefinition("MyCRD").Result(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "CRD is established & not accepting names - not ready",
|
|
crd: builder.ForCustomResourceDefinition("MyCRD").
|
|
Condition(builder.ForCustomResourceDefinitionCondition().Type(apiextv1beta1.Established).Status(apiextv1beta1.ConditionTrue).Result()).Result(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "CRD is not established & accepting names - not ready",
|
|
crd: builder.ForCustomResourceDefinition("MyCRD").
|
|
Condition(builder.ForCustomResourceDefinitionCondition().Type(apiextv1beta1.NamesAccepted).Status(apiextv1beta1.ConditionTrue).Result()).Result(),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "CRD is established & accepting names - ready",
|
|
crd: builder.ForCustomResourceDefinition("MyCRD").
|
|
Condition(builder.ForCustomResourceDefinitionCondition().Type(apiextv1beta1.Established).Status(apiextv1beta1.ConditionTrue).Result()).
|
|
Condition(builder.ForCustomResourceDefinitionCondition().Type(apiextv1beta1.NamesAccepted).Status(apiextv1beta1.ConditionTrue).Result()).
|
|
Result(),
|
|
want: true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
m, err := runtime.DefaultUnstructuredConverter.ToUnstructured(tc.crd)
|
|
require.NoError(t, err)
|
|
result, err := IsUnstructuredCRDReady(&unstructured.Unstructured{Object: m})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, tc.want, result)
|
|
}
|
|
}
|
|
|
|
// TestFromUnstructuredIntToFloatBug tests for a bug where runtime.DefaultUnstructuredConverter.FromUnstructured can't take a whole number into a float.
|
|
// This test should fail when https://github.com/kubernetes/kubernetes/issues/87675 is fixed upstream, letting us know we can remove the IsUnstructuredCRDReady function.
|
|
func TestFromUnstructuredIntToFloatBug(t *testing.T) {
|
|
b := []byte(`
|
|
{
|
|
"apiVersion": "apiextensions.k8s.io/v1beta1",
|
|
"kind": "CustomResourceDefinition",
|
|
"metadata": {
|
|
"name": "foos.example.foo.com"
|
|
},
|
|
"spec": {
|
|
"group": "example.foo.com",
|
|
"version": "v1alpha1",
|
|
"scope": "Namespaced",
|
|
"names": {
|
|
"plural": "foos",
|
|
"singular": "foo",
|
|
"kind": "Foo"
|
|
},
|
|
"validation": {
|
|
"openAPIV3Schema": {
|
|
"required": [
|
|
"spec"
|
|
],
|
|
"properties": {
|
|
"spec": {
|
|
"required": [
|
|
"bar"
|
|
],
|
|
"properties": {
|
|
"bar": {
|
|
"type": "integer",
|
|
"minimum": 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
`)
|
|
|
|
var obj unstructured.Unstructured
|
|
err := json.Unmarshal(b, &obj)
|
|
require.NoError(t, err)
|
|
|
|
var newCRD apiextv1beta1.CustomResourceDefinition
|
|
err = runtime.DefaultUnstructuredConverter.FromUnstructured(obj.UnstructuredContent(), &newCRD)
|
|
// If there's no error, then the upstream issue is fixed, and we need to remove our workarounds.
|
|
require.Error(t, err)
|
|
}
|