Initial v1.0.0 commit

vendor/github.com/gardener/gardener-resource-manager/pkg/apis/resources/register.go

@@ -0,0 +1,18 @@
+// Copyright (c) 2018 SAP SE or an SAP affiliate company. All rights reserved. This file is licensed under the Apache Software License, v. 2 except as noted otherwise in the LICENSE file
+//
+// 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 resources
+
+// GroupName is the group name use in this package
+const GroupName = "resources.gardener.cloud"

vendor/github.com/gardener/gardener-resource-manager/pkg/apis/resources/v1alpha1/doc.go

@@ -0,0 +1,24 @@
+// Copyright (c) 2019 SAP SE or an SAP affiliate company. All rights reserved. This file is licensed under the Apache Software License, v. 2 except as noted otherwise in the LICENSE file
+//
+// 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.
+
+// +k8s:deepcopy-gen=package
+// +k8s:conversion-gen=github.com/gardener/gardener-resource-manager/pkg/apis/resources
+// +k8s:openapi-gen=true
+// +k8s:defaulter-gen=TypeMeta
+
+//go:generate ../../../../hack/update-codegen.sh
+
+// Package v1alpha1 contains the configuration of the Gardener Resource Manager.
+// +groupName=resources.gardener.cloud
+package v1alpha1 // import "github.com/gardener/gardener-resource-manager/pkg/apis/resources/v1alpha1"

vendor/github.com/gardener/gardener-resource-manager/pkg/apis/resources/v1alpha1/register.go

@@ -0,0 +1,51 @@
+// Copyright (c) 2019 SAP SE or an SAP affiliate company. All rights reserved. This file is licensed under the Apache Software License, v. 2 except as noted otherwise in the LICENSE file
+//
+// 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 v1alpha1
+
+import (
+	resources "github.com/gardener/gardener-resource-manager/pkg/apis/resources"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+// SchemeGroupVersion is group version used to register these objects
+var SchemeGroupVersion = schema.GroupVersion{Group: resources.GroupName, Version: "v1alpha1"}
+
+// Kind takes an unqualified kind and returns back a Group qualified GroupKind
+func Kind(kind string) schema.GroupKind {
+	return SchemeGroupVersion.WithKind(kind).GroupKind()
+}
+
+// Resource takes an unqualified resource and returns a Group qualified GroupResource
+func Resource(resource string) schema.GroupResource {
+	return SchemeGroupVersion.WithResource(resource).GroupResource()
+}
+
+var (
+	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes)
+	AddToScheme   = SchemeBuilder.AddToScheme
+)
+
+// Adds the list of known types to Scheme.
+func addKnownTypes(scheme *runtime.Scheme) error {
+	scheme.AddKnownTypes(SchemeGroupVersion,
+		&ManagedResource{},
+		&ManagedResourceList{},
+	)
+	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
+	return nil
+}

vendor/github.com/gardener/gardener-resource-manager/pkg/apis/resources/v1alpha1/types.go

@@ -0,0 +1,170 @@
+// Copyright (c) 2019 SAP SE or an SAP affiliate company. All rights reserved. This file is licensed under the Apache Software License, v. 2 except as noted otherwise in the LICENSE file
+//
+// 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 v1alpha1
+
+import (
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+const (
+	// Ignore is an annotation that dictates whether a resources should be ignored during
+	// reconciliation.
+	Ignore = "resources.gardener.cloud/ignore"
+	// DeleteOnInvalidUpdate is a constant for an annotation on a resource managed by a ManagedResource. If set to
+	// true then the controller will delete the object in case it faces an "Invalid" response during an update operation.
+	DeleteOnInvalidUpdate = "resources.gardener.cloud/delete-on-invalid-update"
+	// KeepObject is a constant for an annotation on a resource managed by a ManagedResource. If set to
+	// true then the controller will not delete the object in case it is removed from the ManagedResource or the
+	// ManagedResource itself is deleted.
+	KeepObject = "resources.gardener.cloud/keep-object"
+)
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// ManagedResource describes a list of managed resources.
+type ManagedResource struct {
+	metav1.TypeMeta `json:",inline"`
+	// Standard object metadata.
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+	// Spec contains the specification of this managed resource.
+	Spec ManagedResourceSpec `json:"spec,omitempty"`
+	// Status contains the status of this managed resource.
+	Status ManagedResourceStatus `json:"status,omitempty"`
+}
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// ManagedResourceList is a list of ManagedResource resources.
+type ManagedResourceList struct {
+	metav1.TypeMeta `json:",inline"`
+	// +optional
+	metav1.ListMeta `json:"metadata,omitempty"`
+
+	// Items is the list of ManagedResource.
+	Items []ManagedResource `json:"items"`
+}
+
+type ManagedResourceSpec struct {
+	// Class holds the resource class used to control the responsibility for multiple resource manager instances
+	// +optional
+	Class *string `json:"class,omitempty"`
+	// SecretRefs is a list of secret references.
+	SecretRefs []corev1.LocalObjectReference `json:"secretRefs"`
+	// InjectLabels injects the provided labels into every resource that is part of the referenced secrets.
+	// +optional
+	InjectLabels map[string]string `json:"injectLabels,omitempty"`
+	// ForceOverwriteLabels specifies that all existing labels should be overwritten. Defaults to false.
+	// +optional
+	ForceOverwriteLabels *bool `json:"forceOverwriteLabels,omitempty"`
+	// ForceOverwriteAnnotations specifies that all existing annotations should be overwritten. Defaults to false.
+	// +optional
+	ForceOverwriteAnnotations *bool `json:"forceOverwriteAnnotations,omitempty"`
+	// KeepObjects specifies whether the objects should be kept although the managed resource has already been deleted.
+	// Defaults to false.
+	// +optional
+	KeepObjects *bool `json:"keepObjects,omitempty"`
+	// Equivalences specifies possible group/kind equivalences for objects.
+	// +optional
+	Equivalences [][]metav1.GroupKind `json:"equivalences,omitempty"`
+	// DeletePersistentVolumeClaims specifies if PersistentVolumeClaims created by StatefulSets, which are managed by this
+	// resource, should also be deleted when the corresponding StatefulSet is deleted (defaults to false).
+	// +optional
+	DeletePersistentVolumeClaims *bool `json:"deletePersistentVolumeClaims,omitempty"`
+}
+
+// ManagedResourceStatus is the status of a managed resource.
+type ManagedResourceStatus struct {
+	Conditions []ManagedResourceCondition `json:"conditions,omitempty"`
+	// ObservedGeneration is the most recent generation observed for this resource.
+	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
+	// Resources is a list of objects that have been created.
+	// +optional
+	Resources []ObjectReference `json:"resources,omitempty"`
+}
+
+type ObjectReference struct {
+	corev1.ObjectReference `json:",inline"`
+	// Labels is a map of labels that were used during last update of the resource.
+	Labels map[string]string `json:"labels,omitempty"`
+	// Annotations is a map of annotations that were used during last update of the resource.
+	Annotations map[string]string `json:"annotations,omitempty"`
+}
+
+// ConditionType is the type of a condition.
+type ConditionType string
+
+const (
+	// ResourcesApplied is a condition type that indicates whether all resources are applied to the target cluster.
+	ResourcesApplied ConditionType = "ResourcesApplied"
+	// ResourcesHealthy is a condition type that indicates whether all resources are present and healthy.
+	ResourcesHealthy ConditionType = "ResourcesHealthy"
+)
+
+// ConditionStatus is the status of a condition.
+type ConditionStatus string
+
+// These are valid condition statuses.
+const (
+	// ConditionTrue means a resource is in the condition.
+	ConditionTrue ConditionStatus = "True"
+	// ConditionFalse means a resource is not in the condition.
+	ConditionFalse ConditionStatus = "False"
+	// ConditionUnknown means that the controller can't decide if a resource is in the condition or not
+	ConditionUnknown ConditionStatus = "Unknown"
+	// ConditionProgressing means that the controller is currently acting on the resource and the condition is therefore progressing.
+	ConditionProgressing ConditionStatus = "Progressing"
+)
+
+// These are well-known reasons for ManagedResourceConditions.
+const (
+	// ConditionApplySucceeded indicates that the `ResourcesApplied` condition is `True`,
+	// because all resources have been applied successfully.
+	ConditionApplySucceeded = "ApplySucceeded"
+	// ConditionApplyFailed indicates that the `ResourcesApplied` condition is `False`,
+	// because applying the resources failed.
+	ConditionApplyFailed = "ApplyFailed"
+	// ConditionDecodingFailed indicates that the `ResourcesApplied` condition is `False`,
+	// because decoding the resources of the ManagedResource failed.
+	ConditionDecodingFailed = "DecodingFailed"
+	// ConditionApplyProgressing indicates that the `ResourcesApplied` condition is `Progressing`,
+	// because the resources are currently being reconciled.
+	ConditionApplyProgressing = "ApplyProgressing"
+	// ConditionDeletionFailed indicates that the `ResourcesApplied` condition is `False`,
+	// because deleting the resources failed.
+	ConditionDeletionFailed = "DeletionFailed"
+	// ConditionDeletionPending indicates that the `ResourcesApplied` condition is `Progressing`,
+	// because the deletion of some resources are still pending.
+	ConditionDeletionPending = "DeletionPending"
+	// ConditionHealthChecksPending indicates that the `ResourcesHealthy` condition is `Unknown`,
+	// because the health checks have not been completely executed yet for the current set of resources.
+	ConditionHealthChecksPending = "HealthChecksPending"
+)
+
+// ManagedResourceCondition describes the state of a deployment at a certain period.
+type ManagedResourceCondition struct {
+	// Type of the ManagedResource condition.
+	Type ConditionType `json:"type"`
+	// Status of the ManagedResource condition.
+	Status ConditionStatus `json:"status"`
+	// Last time the condition was updated.
+	LastUpdateTime metav1.Time `json:"lastUpdateTime"`
+	// Last time the condition transitioned from one status to another.
+	LastTransitionTime metav1.Time `json:"lastTransitionTime"`
+	// The reason for the condition's last transition.
+	Reason string `json:"reason"`
+	// A human readable message indicating details about the transition.
+	Message string `json:"message"`
+}

vendor/github.com/gardener/gardener-resource-manager/pkg/apis/resources/v1alpha1/zz_generated.deepcopy.go

@@ -0,0 +1,231 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright (c) 2020 SAP SE or an SAP affiliate company. All rights reserved. This file is licensed under the Apache Software License, v. 2 except as noted otherwise in the LICENSE file
+
+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.
+*/
+
+// Code generated by deepcopy-gen. DO NOT EDIT.
+
+package v1alpha1
+
+import (
+	v1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+)
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ManagedResource) DeepCopyInto(out *ManagedResource) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	in.Spec.DeepCopyInto(&out.Spec)
+	in.Status.DeepCopyInto(&out.Status)
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ManagedResource.
+func (in *ManagedResource) DeepCopy() *ManagedResource {
+	if in == nil {
+		return nil
+	}
+	out := new(ManagedResource)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *ManagedResource) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ManagedResourceCondition) DeepCopyInto(out *ManagedResourceCondition) {
+	*out = *in
+	in.LastUpdateTime.DeepCopyInto(&out.LastUpdateTime)
+	in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime)
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ManagedResourceCondition.
+func (in *ManagedResourceCondition) DeepCopy() *ManagedResourceCondition {
+	if in == nil {
+		return nil
+	}
+	out := new(ManagedResourceCondition)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ManagedResourceList) DeepCopyInto(out *ManagedResourceList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ListMeta.DeepCopyInto(&out.ListMeta)
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]ManagedResource, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ManagedResourceList.
+func (in *ManagedResourceList) DeepCopy() *ManagedResourceList {
+	if in == nil {
+		return nil
+	}
+	out := new(ManagedResourceList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *ManagedResourceList) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ManagedResourceSpec) DeepCopyInto(out *ManagedResourceSpec) {
+	*out = *in
+	if in.Class != nil {
+		in, out := &in.Class, &out.Class
+		*out = new(string)
+		**out = **in
+	}
+	if in.SecretRefs != nil {
+		in, out := &in.SecretRefs, &out.SecretRefs
+		*out = make([]v1.LocalObjectReference, len(*in))
+		copy(*out, *in)
+	}
+	if in.InjectLabels != nil {
+		in, out := &in.InjectLabels, &out.InjectLabels
+		*out = make(map[string]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	if in.ForceOverwriteLabels != nil {
+		in, out := &in.ForceOverwriteLabels, &out.ForceOverwriteLabels
+		*out = new(bool)
+		**out = **in
+	}
+	if in.ForceOverwriteAnnotations != nil {
+		in, out := &in.ForceOverwriteAnnotations, &out.ForceOverwriteAnnotations
+		*out = new(bool)
+		**out = **in
+	}
+	if in.KeepObjects != nil {
+		in, out := &in.KeepObjects, &out.KeepObjects
+		*out = new(bool)
+		**out = **in
+	}
+	if in.Equivalences != nil {
+		in, out := &in.Equivalences, &out.Equivalences
+		*out = make([][]metav1.GroupKind, len(*in))
+		for i := range *in {
+			if (*in)[i] != nil {
+				in, out := &(*in)[i], &(*out)[i]
+				*out = make([]metav1.GroupKind, len(*in))
+				copy(*out, *in)
+			}
+		}
+	}
+	if in.DeletePersistentVolumeClaims != nil {
+		in, out := &in.DeletePersistentVolumeClaims, &out.DeletePersistentVolumeClaims
+		*out = new(bool)
+		**out = **in
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ManagedResourceSpec.
+func (in *ManagedResourceSpec) DeepCopy() *ManagedResourceSpec {
+	if in == nil {
+		return nil
+	}
+	out := new(ManagedResourceSpec)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ManagedResourceStatus) DeepCopyInto(out *ManagedResourceStatus) {
+	*out = *in
+	if in.Conditions != nil {
+		in, out := &in.Conditions, &out.Conditions
+		*out = make([]ManagedResourceCondition, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	if in.Resources != nil {
+		in, out := &in.Resources, &out.Resources
+		*out = make([]ObjectReference, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ManagedResourceStatus.
+func (in *ManagedResourceStatus) DeepCopy() *ManagedResourceStatus {
+	if in == nil {
+		return nil
+	}
+	out := new(ManagedResourceStatus)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ObjectReference) DeepCopyInto(out *ObjectReference) {
+	*out = *in
+	out.ObjectReference = in.ObjectReference
+	if in.Labels != nil {
+		in, out := &in.Labels, &out.Labels
+		*out = make(map[string]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	if in.Annotations != nil {
+		in, out := &in.Annotations, &out.Annotations
+		*out = make(map[string]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ObjectReference.
+func (in *ObjectReference) DeepCopy() *ObjectReference {
+	if in == nil {
+		return nil
+	}
+	out := new(ObjectReference)
+	in.DeepCopyInto(out)
+	return out
+}

vendor/github.com/gardener/gardener-resource-manager/pkg/manager/managedresources.go

@@ -0,0 +1,120 @@
+// Copyright (c) 2019 SAP SE or an SAP affiliate company. All rights reserved. This file is licensed under the Apache Software License, v. 2 except as noted otherwise in the LICENSE file
+//
+// 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 manager
+
+import (
+	"context"
+
+	resourcesv1alpha1 "github.com/gardener/gardener-resource-manager/pkg/apis/resources/v1alpha1"
+
+	corev1 "k8s.io/api/core/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
+)
+
+type ManagedResource struct {
+	client   client.Client
+	resource *resourcesv1alpha1.ManagedResource
+}
+
+func NewManagedResource(client client.Client) *ManagedResource {
+	return &ManagedResource{
+		client:   client,
+		resource: &resourcesv1alpha1.ManagedResource{},
+	}
+}
+
+func (m *ManagedResource) WithNamespacedName(namespace, name string) *ManagedResource {
+	m.resource.Namespace = namespace
+	m.resource.Name = name
+	return m
+}
+
+func (m *ManagedResource) WithLabels(labels map[string]string) *ManagedResource {
+	m.resource.Labels = labels
+	return m
+}
+
+func (m *ManagedResource) WithAnnotations(annotations map[string]string) *ManagedResource {
+	m.resource.Annotations = annotations
+	return m
+}
+
+func (m *ManagedResource) WithClass(name string) *ManagedResource {
+	if name == "" {
+		m.resource.Spec.Class = nil
+	} else {
+		m.resource.Spec.Class = &name
+	}
+	return m
+}
+
+func (m *ManagedResource) WithSecretRef(secretRefName string) *ManagedResource {
+	m.resource.Spec.SecretRefs = append(m.resource.Spec.SecretRefs, corev1.LocalObjectReference{Name: secretRefName})
+	return m
+}
+
+func (m *ManagedResource) WithSecretRefs(secretRefs []corev1.LocalObjectReference) *ManagedResource {
+	m.resource.Spec.SecretRefs = append(m.resource.Spec.SecretRefs, secretRefs...)
+	return m
+}
+
+func (m *ManagedResource) WithInjectedLabels(labelsToInject map[string]string) *ManagedResource {
+	m.resource.Spec.InjectLabels = labelsToInject
+	return m
+}
+
+func (m *ManagedResource) ForceOverwriteAnnotations(v bool) *ManagedResource {
+	m.resource.Spec.ForceOverwriteAnnotations = &v
+	return m
+}
+
+func (m *ManagedResource) ForceOverwriteLabels(v bool) *ManagedResource {
+	m.resource.Spec.ForceOverwriteLabels = &v
+	return m
+}
+
+func (m *ManagedResource) KeepObjects(v bool) *ManagedResource {
+	m.resource.Spec.KeepObjects = &v
+	return m
+}
+
+func (m *ManagedResource) DeletePersistentVolumeClaims(v bool) *ManagedResource {
+	m.resource.Spec.DeletePersistentVolumeClaims = &v
+	return m
+}
+
+func (m *ManagedResource) Reconcile(ctx context.Context) error {
+	resource := &resourcesv1alpha1.ManagedResource{
+		ObjectMeta: metav1.ObjectMeta{Name: m.resource.Name, Namespace: m.resource.Namespace},
+	}
+
+	_, err := controllerutil.CreateOrUpdate(ctx, m.client, resource, func() error {
+		resource.Labels = m.resource.Labels
+		resource.Annotations = m.resource.Annotations
+		resource.Spec = m.resource.Spec
+		return nil
+	})
+	return err
+}
+
+func (m *ManagedResource) Delete(ctx context.Context) error {
+	if err := m.client.Delete(ctx, m.resource); err != nil && !apierrors.IsNotFound(err) {
+		return err
+	}
+	return nil
+}

vendor/github.com/gardener/gardener-resource-manager/pkg/manager/managedsecrets.go

@@ -0,0 +1,124 @@
+// Copyright (c) 2019 SAP SE or an SAP affiliate company. All rights reserved. This file is licensed under the Apache Software License, v. 2 except as noted otherwise in the LICENSE file
+//
+// 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 manager
+
+import (
+	"context"
+
+	corev1 "k8s.io/api/core/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
+)
+
+type Secret struct {
+	client client.Client
+
+	keyValues map[string]string
+	secret    *corev1.Secret
+}
+
+func NewSecret(client client.Client) *Secret {
+	return &Secret{
+		client:    client,
+		keyValues: make(map[string]string),
+		secret:    &corev1.Secret{},
+	}
+}
+
+func (s *Secret) WithNamespacedName(namespace, name string) *Secret {
+	s.secret.Namespace = namespace
+	s.secret.Name = name
+	return s
+}
+
+func (s *Secret) WithLabels(labels map[string]string) *Secret {
+	s.secret.Labels = labels
+	return s
+}
+
+func (s *Secret) WithAnnotations(annotations map[string]string) *Secret {
+	s.secret.Annotations = annotations
+	return s
+}
+
+func (s *Secret) WithKeyValues(keyValues map[string][]byte) *Secret {
+	s.secret.Data = keyValues
+	return s
+}
+
+func (s *Secret) Reconcile(ctx context.Context) error {
+	secret := &corev1.Secret{
+		ObjectMeta: metav1.ObjectMeta{Name: s.secret.Name, Namespace: s.secret.Namespace},
+	}
+
+	_, err := controllerutil.CreateOrUpdate(ctx, s.client, secret, func() error {
+		secret.Labels = s.secret.Labels
+		secret.Annotations = s.secret.Annotations
+		secret.Type = corev1.SecretTypeOpaque
+		secret.Data = s.secret.Data
+		return nil
+	})
+	return err
+}
+
+func (s *Secret) Delete(ctx context.Context) error {
+	if err := s.client.Delete(ctx, s.secret); err != nil && !apierrors.IsNotFound(err) {
+		return err
+	}
+	return nil
+}
+
+type Secrets struct {
+	client client.Client
+
+	secrets []Secret
+}
+
+func NewSecrets(client client.Client) *Secrets {
+	return &Secrets{
+		client:  client,
+		secrets: []Secret{},
+	}
+}
+
+func (s *Secrets) WithSecretList(secrets []Secret) *Secrets {
+	s.secrets = append(s.secrets, secrets...)
+	return s
+}
+
+func (s *Secrets) WithSecret(secrets Secret) *Secrets {
+	s.secrets = append(s.secrets, secrets)
+	return s
+}
+
+func (s *Secrets) Reconcile(ctx context.Context) error {
+	for _, secret := range s.secrets {
+		if err := secret.Reconcile(ctx); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *Secrets) Delete(ctx context.Context) error {
+	for _, secret := range s.secrets {
+		if err := secret.Delete(ctx); err != nil {
+			return err
+		}
+	}
+	return nil
+}