apitech
/
loki
mirror of https://github.com/grafana/loki
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Add owner watches for LokiStack owned resources (#42)

Browse Source
pull/4881/head
Periklis Tsirakidis 4 years ago committed by GitHub
parent b55f2313a0
commit c5fab0a33b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 866 additions and 115 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 5
      Makefile
  2. 56
      controllers/lokistack_controller.go
  3. 111
      controllers/lokistack_controller_test.go
  4. 98
      controllers/suite_test.go
  5. 67
      internal/external/k8s/builder.go
  6. 644
      internal/external/k8s/k8sfakes/fake_builder.go

5
Makefile
Unescape View File

@ -71,12 +71,9 @@ all: generate lint manager bin/loki-broker
OCI_RUNTIME ?= $(shell which podman || which docker)
# Run tests
ENVTEST_ASSETS_DIR=$(CURDIR)/testbin
test: generate go-generate lint manifests
test: $(GO_FILES)
@mkdir -p ${ENVTEST_ASSETS_DIR}
@test -f ${ENVTEST_ASSETS_DIR}/setup-envtest.sh || curl -sSLo ${ENVTEST_ASSETS_DIR}/setup-envtest.sh https://raw.githubusercontent.com/kubernetes-sigs/controller-runtime/v0.7.0/hack/setup-envtest.sh
source ${ENVTEST_ASSETS_DIR}/setup-envtest.sh; fetch_envtest_tools $(ENVTEST_ASSETS_DIR); setup_envtest_env $(ENVTEST_ASSETS_DIR); go test ./... -coverprofile cover.out
go test ./... -coverprofile cover.out
# Build manager binary
manager: generate

56
controllers/lokistack_controller.go
Unescape View File

@ -21,17 +21,49 @@ import (
"time"
"github.com/ViaQ/loki-operator/controllers/internal/management/state"
"github.com/ViaQ/loki-operator/internal/external/k8s"
"github.com/ViaQ/loki-operator/internal/handlers"
"github.com/go-logr/logr"
appsv1 "k8s.io/api/apps/v1"
corev1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/runtime"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/builder"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/event"
"sigs.k8s.io/controller-runtime/pkg/manager"
"sigs.k8s.io/controller-runtime/pkg/predicate"
lokiv1beta1 "github.com/ViaQ/loki-operator/api/v1beta1"
)
var (
createOrUpdateOnlyPred = builder.WithPredicates(predicate.Funcs{
UpdateFunc: func(e event.UpdateEvent) bool {
// Update only if generation changes, filter out anything else.
// We only need to check generation here, because it is only
// updated on spec changes. On the other hand RevisionVersion
// changes also on status changes. We want to omit reconciliation
// for status updates for now.
return e.ObjectOld.GetGeneration() != e.ObjectNew.GetGeneration()
},
CreateFunc: func(e event.CreateEvent) bool { return true },
DeleteFunc: func(e event.DeleteEvent) bool { return false },
GenericFunc: func(e event.GenericEvent) bool { return false },
})
deleteOnlyPred = builder.WithPredicates(predicate.Funcs{
UpdateFunc: func(e event.UpdateEvent) bool { return false },
CreateFunc: func(e event.CreateEvent) bool { return false },
DeleteFunc: func(e event.DeleteEvent) bool {
// DeleteStateUnknown evaluates to false only if the object
// has been confirmed as deleted by the api server.
return !e.DeleteStateUnknown
},
GenericFunc: func(e event.GenericEvent) bool { return false },
})
)
// LokiStackReconciler reconciles a LokiStack object
type LokiStackReconciler struct {
client.Client
@ -80,19 +112,17 @@ func (r *LokiStackReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
}
// SetupWithManager sets up the controller with the Manager.
func (r *LokiStackReconciler) SetupWithManager(mgr ctrl.Manager) error {
filter := predicate.Funcs{
UpdateFunc: func(e event.UpdateEvent) bool {
// Update only if generation changes, filter out anything else
return e.ObjectOld.GetGeneration() != e.ObjectNew.GetGeneration()
},
CreateFunc: func(e event.CreateEvent) bool { return true },
DeleteFunc: func(e event.DeleteEvent) bool { return false },
GenericFunc: func(e event.GenericEvent) bool { return false },
}
func (r *LokiStackReconciler) SetupWithManager(mgr manager.Manager) error {
b := ctrl.NewControllerManagedBy(mgr)
return r.buildController(k8s.NewCtrlBuilder(b))
}
return ctrl.NewControllerManagedBy(mgr).
For(&lokiv1beta1.LokiStack{}).
WithEventFilter(filter).
func (r *LokiStackReconciler) buildController(bld k8s.Builder) error {
return bld.
For(&lokiv1beta1.LokiStack{}, createOrUpdateOnlyPred).
Owns(&corev1.ConfigMap{}, deleteOnlyPred).
Owns(&corev1.Service{}, deleteOnlyPred).
Owns(&appsv1.Deployment{}, deleteOnlyPred).
Owns(&appsv1.StatefulSet{}, deleteOnlyPred).
Complete(r)
}

111
controllers/lokistack_controller_test.go
Unescape View File

@ -0,0 +1,111 @@
package controllers
import (
"flag"
"io/ioutil"
"os"
"testing"
"github.com/ViaQ/logerr/log"
lokiv1beta1 "github.com/ViaQ/loki-operator/api/v1beta1"
"github.com/ViaQ/loki-operator/internal/external/k8s/k8sfakes"
"github.com/stretchr/testify/require"
"sigs.k8s.io/controller-runtime/pkg/builder"
"sigs.k8s.io/controller-runtime/pkg/client"
appsv1 "k8s.io/api/apps/v1"
corev1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/runtime"
utilruntime "k8s.io/apimachinery/pkg/util/runtime"
clientgoscheme "k8s.io/client-go/kubernetes/scheme"
)
var scheme = runtime.NewScheme()
func TestMain(m *testing.M) {
testing.Init()
flag.Parse()
if testing.Verbose() {
// set to the highest for verbose testing
log.SetLogLevel(5)
} else {
if err := log.SetOutput(ioutil.Discard); err != nil {
// This would only happen if the default logger was changed which it hasn't so
// we can assume that a panic is necessary and the developer is to blame.
panic(err)
}
}
// Register the clientgo and CRD schemes
utilruntime.Must(clientgoscheme.AddToScheme(scheme))
utilruntime.Must(lokiv1beta1.AddToScheme(scheme))
log.Init("testing")
os.Exit(m.Run())
}
func TestLokiStackController_RegistersCustomResourceForCreateOrUpdate(t *testing.T) {
b := &k8sfakes.FakeBuilder{}
k := &k8sfakes.FakeClient{}
c := &LokiStackReconciler{Client: k, Scheme: scheme}
b.ForReturns(b)
b.OwnsReturns(b)
err := c.buildController(b)
require.NoError(t, err)
// Require only one For-Call for the custom resource
require.Equal(t, 1, b.ForCallCount())
// Require For-call options to have create and update predicates
obj, opts := b.ForArgsForCall(0)
require.Equal(t, &lokiv1beta1.LokiStack{}, obj)
require.Equal(t, opts[0], createOrUpdateOnlyPred)
}
func TestLokiStackController_RegisterOwnedResourcesForDeleteOnly(t *testing.T) {
b := &k8sfakes.FakeBuilder{}
k := &k8sfakes.FakeClient{}
c := &LokiStackReconciler{Client: k, Scheme: scheme}
b.ForReturns(b)
b.OwnsReturns(b)
err := c.buildController(b)
require.NoError(t, err)
// Require Owns-Calls for all owned resources
require.Equal(t, 4, b.OwnsCallCount())
// Require owned resources
type test struct {
obj client.Object
pred builder.OwnsOption
}
table := []test{
{
obj: &corev1.ConfigMap{},
pred: deleteOnlyPred,
},
{
obj: &corev1.Service{},
pred: deleteOnlyPred,
},
{
obj: &appsv1.Deployment{},
pred: deleteOnlyPred,
},
{
obj: &appsv1.StatefulSet{},
pred: deleteOnlyPred,
},
}
for i, tst := range table {
// Require Owns-call options to have delete predicate only
obj, opts := b.OwnsArgsForCall(i)
require.Equal(t, tst.obj, obj)
require.Equal(t, tst.pred, opts[0])
}
}

98
controllers/suite_test.go
Unescape View File

@ -1,98 +0,0 @@
/*
Copyright 2021.
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 controllers
import (
"flag"
"fmt"
"os"
"path/filepath"
"testing"
"github.com/ViaQ/logerr/log"
lokiv1beta1 "github.com/ViaQ/loki-operator/api/v1beta1"
"k8s.io/client-go/kubernetes/scheme"
"k8s.io/client-go/rest"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/envtest"
// +kubebuilder:scaffold:imports
)
var (
testEnv *envtest.Environment
cfg *rest.Config
k8sClient client.Client
)
func TestMain(m *testing.M) {
testing.Init()
flag.Parse()
// Do not run this unless we intend to run integration testing. This stuff is dark magic.
if envStr := os.Getenv("INTEGRATION"); envStr == "" {
return
}
if testing.Short() {
return
}
Setup()
defer Teardown()
m.Run()
}
func Setup() {
log.Init("integration-testing")
log.Info("bootstrapping integration test environment")
testEnv = &envtest.Environment{
CRDDirectoryPaths: []string{filepath.Join("..", "config", "crd", "bases")},
}
var err error
cfg, err = testEnv.Start()
if err != nil {
log.Error(err, "failed to start test env")
os.Exit(1)
}
if cfg == nil {
log.Error(fmt.Errorf("config was nil"), "failed to start test env")
os.Exit(1)
}
if err = lokiv1beta1.AddToScheme(scheme.Scheme); err != nil {
log.Error(err, "failed to AddToScheme")
os.Exit(1)
}
// +kubebuilder:scaffold:scheme
k8sClient, err = client.New(cfg, client.Options{Scheme: scheme.Scheme})
if err != nil {
log.Error(err, "failed to create test k8sclient")
os.Exit(1)
}
if cfg == nil {
log.Error(fmt.Errorf("k8sClient was nil"), "failed to connect k8s client")
os.Exit(1)
}
}
func Teardown() {
log.Info("tearing down test suite")
testEnv.Stop()
}

67
internal/external/k8s/builder.go vendored
Unescape View File

@ -0,0 +1,67 @@
package k8s
import (
"github.com/go-logr/logr"
"sigs.k8s.io/controller-runtime/pkg/builder"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/controller"
"sigs.k8s.io/controller-runtime/pkg/predicate"
"sigs.k8s.io/controller-runtime/pkg/reconcile"
)
// Builder is a controller-runtime interface used internally. It copies function from
// sigs.k8s.io/controller-runtime/pkg/builder
//
//counterfeiter:generate . Builder
type Builder interface {
For(object client.Object, opts ...builder.ForOption) Builder
Owns(object client.Object, opts ...builder.OwnsOption) Builder
WithEventFilter(p predicate.Predicate) Builder
WithOptions(options controller.Options) Builder
WithLogger(log logr.Logger) Builder
Named(name string) Builder
Complete(r reconcile.Reconciler) error
Build(r reconcile.Reconciler) (controller.Controller, error)
}
type ctrlBuilder struct {
bld *builder.Builder
}
// NewCtrlBuilder returns a self-referencing controlled builder
// passthrough wrapper implementing the Builder interface above.
func NewCtrlBuilder(b *builder.Builder) Builder {
return &ctrlBuilder{bld: b}
}
func (b *ctrlBuilder) For(object client.Object, opts ...builder.ForOption) Builder {
return &ctrlBuilder{bld: b.bld.For(object, opts...)}
}
func (b *ctrlBuilder) Owns(object client.Object, opts ...builder.OwnsOption) Builder {
return &ctrlBuilder{bld: b.bld.Owns(object, opts...)}
}
func (b *ctrlBuilder) WithEventFilter(p predicate.Predicate) Builder {
return &ctrlBuilder{bld: b.bld.WithEventFilter(p)}
}
func (b *ctrlBuilder) WithOptions(opts controller.Options) Builder {
return &ctrlBuilder{bld: b.bld.WithOptions(opts)}
}
func (b *ctrlBuilder) WithLogger(log logr.Logger) Builder {
return &ctrlBuilder{bld: b.bld.WithLogger(log)}
}
func (b *ctrlBuilder) Named(name string) Builder {
return &ctrlBuilder{bld: b.bld.Named(name)}
}
func (b *ctrlBuilder) Complete(r reconcile.Reconciler) error {
return b.bld.Complete(r)
}
func (b *ctrlBuilder) Build(r reconcile.Reconciler) (controller.Controller, error) {
return b.bld.Build(r)
}

644
internal/external/k8s/k8sfakes/fake_builder.go vendored
Unescape View File

@ -0,0 +1,644 @@
// Code generated by counterfeiter. DO NOT EDIT.
package k8sfakes
import (
"sync"
"github.com/ViaQ/loki-operator/internal/external/k8s"
"github.com/go-logr/logr"
"sigs.k8s.io/controller-runtime/pkg/builder"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/controller"
"sigs.k8s.io/controller-runtime/pkg/predicate"
"sigs.k8s.io/controller-runtime/pkg/reconcile"
)
type FakeBuilder struct {
BuildStub func(reconcile.Reconciler) (controller.Controller, error)
buildMutex sync.RWMutex
buildArgsForCall []struct {
arg1 reconcile.Reconciler
}
buildReturns struct {
result1 controller.Controller
result2 error
}
buildReturnsOnCall map[int]struct {
result1 controller.Controller
result2 error
}
CompleteStub func(reconcile.Reconciler) error
completeMutex sync.RWMutex
completeArgsForCall []struct {
arg1 reconcile.Reconciler
}
completeReturns struct {
result1 error
}
completeReturnsOnCall map[int]struct {
result1 error
}
ForStub func(client.Object, ...builder.ForOption) k8s.Builder
forMutex sync.RWMutex
forArgsForCall []struct {
arg1 client.Object
arg2 []builder.ForOption
}
forReturns struct {
result1 k8s.Builder
}
forReturnsOnCall map[int]struct {
result1 k8s.Builder
}
NamedStub func(string) k8s.Builder
namedMutex sync.RWMutex
namedArgsForCall []struct {
arg1 string
}
namedReturns struct {
result1 k8s.Builder
}
namedReturnsOnCall map[int]struct {
result1 k8s.Builder
}
OwnsStub func(client.Object, ...builder.OwnsOption) k8s.Builder
ownsMutex sync.RWMutex
ownsArgsForCall []struct {
arg1 client.Object
arg2 []builder.OwnsOption
}
ownsReturns struct {
result1 k8s.Builder
}
ownsReturnsOnCall map[int]struct {
result1 k8s.Builder
}
WithEventFilterStub func(predicate.Predicate) k8s.Builder
withEventFilterMutex sync.RWMutex
withEventFilterArgsForCall []struct {
arg1 predicate.Predicate
}
withEventFilterReturns struct {
result1 k8s.Builder
}
withEventFilterReturnsOnCall map[int]struct {
result1 k8s.Builder
}
WithLoggerStub func(logr.Logger) k8s.Builder
withLoggerMutex sync.RWMutex
withLoggerArgsForCall []struct {
arg1 logr.Logger
}
withLoggerReturns struct {
result1 k8s.Builder
}
withLoggerReturnsOnCall map[int]struct {
result1 k8s.Builder
}
WithOptionsStub func(controller.Options) k8s.Builder
withOptionsMutex sync.RWMutex
withOptionsArgsForCall []struct {
arg1 controller.Options
}
withOptionsReturns struct {
result1 k8s.Builder
}
withOptionsReturnsOnCall map[int]struct {
result1 k8s.Builder
}
invocations map[string][][]interface{}
invocationsMutex sync.RWMutex
}
func (fake *FakeBuilder) Build(arg1 reconcile.Reconciler) (controller.Controller, error) {
fake.buildMutex.Lock()
ret, specificReturn := fake.buildReturnsOnCall[len(fake.buildArgsForCall)]
fake.buildArgsForCall = append(fake.buildArgsForCall, struct {
arg1 reconcile.Reconciler
}{arg1})
stub := fake.BuildStub
fakeReturns := fake.buildReturns
fake.recordInvocation("Build", []interface{}{arg1})
fake.buildMutex.Unlock()
if stub != nil {
return stub(arg1)
}
if specificReturn {
return ret.result1, ret.result2
}
return fakeReturns.result1, fakeReturns.result2
}
func (fake *FakeBuilder) BuildCallCount() int {
fake.buildMutex.RLock()
defer fake.buildMutex.RUnlock()
return len(fake.buildArgsForCall)
}
func (fake *FakeBuilder) BuildCalls(stub func(reconcile.Reconciler) (controller.Controller, error)) {
fake.buildMutex.Lock()
defer fake.buildMutex.Unlock()
fake.BuildStub = stub
}
func (fake *FakeBuilder) BuildArgsForCall(i int) reconcile.Reconciler {
fake.buildMutex.RLock()
defer fake.buildMutex.RUnlock()
argsForCall := fake.buildArgsForCall[i]
return argsForCall.arg1
}
func (fake *FakeBuilder) BuildReturns(result1 controller.Controller, result2 error) {
fake.buildMutex.Lock()
defer fake.buildMutex.Unlock()
fake.BuildStub = nil
fake.buildReturns = struct {
result1 controller.Controller
result2 error
}{result1, result2}
}
func (fake *FakeBuilder) BuildReturnsOnCall(i int, result1 controller.Controller, result2 error) {
fake.buildMutex.Lock()
defer fake.buildMutex.Unlock()
fake.BuildStub = nil
if fake.buildReturnsOnCall == nil {
fake.buildReturnsOnCall = make(map[int]struct {
result1 controller.Controller
result2 error
})
}
fake.buildReturnsOnCall[i] = struct {
result1 controller.Controller
result2 error
}{result1, result2}
}
func (fake *FakeBuilder) Complete(arg1 reconcile.Reconciler) error {
fake.completeMutex.Lock()
ret, specificReturn := fake.completeReturnsOnCall[len(fake.completeArgsForCall)]
fake.completeArgsForCall = append(fake.completeArgsForCall, struct {
arg1 reconcile.Reconciler
}{arg1})
stub := fake.CompleteStub
fakeReturns := fake.completeReturns
fake.recordInvocation("Complete", []interface{}{arg1})
fake.completeMutex.Unlock()
if stub != nil {
return stub(arg1)
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *FakeBuilder) CompleteCallCount() int {
fake.completeMutex.RLock()
defer fake.completeMutex.RUnlock()
return len(fake.completeArgsForCall)
}
func (fake *FakeBuilder) CompleteCalls(stub func(reconcile.Reconciler) error) {
fake.completeMutex.Lock()
defer fake.completeMutex.Unlock()
fake.CompleteStub = stub
}
func (fake *FakeBuilder) CompleteArgsForCall(i int) reconcile.Reconciler {
fake.completeMutex.RLock()
defer fake.completeMutex.RUnlock()
argsForCall := fake.completeArgsForCall[i]
return argsForCall.arg1
}
func (fake *FakeBuilder) CompleteReturns(result1 error) {
fake.completeMutex.Lock()
defer fake.completeMutex.Unlock()
fake.CompleteStub = nil
fake.completeReturns = struct {
result1 error
}{result1}
}
func (fake *FakeBuilder) CompleteReturnsOnCall(i int, result1 error) {
fake.completeMutex.Lock()
defer fake.completeMutex.Unlock()
fake.CompleteStub = nil
if fake.completeReturnsOnCall == nil {
fake.completeReturnsOnCall = make(map[int]struct {
result1 error
})
}
fake.completeReturnsOnCall[i] = struct {
result1 error
}{result1}
}
func (fake *FakeBuilder) For(arg1 client.Object, arg2 ...builder.ForOption) k8s.Builder {
fake.forMutex.Lock()
ret, specificReturn := fake.forReturnsOnCall[len(fake.forArgsForCall)]
fake.forArgsForCall = append(fake.forArgsForCall, struct {
arg1 client.Object
arg2 []builder.ForOption
}{arg1, arg2})
stub := fake.ForStub
fakeReturns := fake.forReturns
fake.recordInvocation("For", []interface{}{arg1, arg2})
fake.forMutex.Unlock()
if stub != nil {
return stub(arg1, arg2...)
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *FakeBuilder) ForCallCount() int {
fake.forMutex.RLock()
defer fake.forMutex.RUnlock()
return len(fake.forArgsForCall)
}
func (fake *FakeBuilder) ForCalls(stub func(client.Object, ...builder.ForOption) k8s.Builder) {
fake.forMutex.Lock()
defer fake.forMutex.Unlock()
fake.ForStub = stub
}
func (fake *FakeBuilder) ForArgsForCall(i int) (client.Object, []builder.ForOption) {
fake.forMutex.RLock()
defer fake.forMutex.RUnlock()
argsForCall := fake.forArgsForCall[i]
return argsForCall.arg1, argsForCall.arg2
}
func (fake *FakeBuilder) ForReturns(result1 k8s.Builder) {
fake.forMutex.Lock()
defer fake.forMutex.Unlock()
fake.ForStub = nil
fake.forReturns = struct {
result1 k8s.Builder
}{result1}
}
func (fake *FakeBuilder) ForReturnsOnCall(i int, result1 k8s.Builder) {
fake.forMutex.Lock()
defer fake.forMutex.Unlock()
fake.ForStub = nil
if fake.forReturnsOnCall == nil {
fake.forReturnsOnCall = make(map[int]struct {
result1 k8s.Builder
})
}
fake.forReturnsOnCall[i] = struct {
result1 k8s.Builder
}{result1}
}
func (fake *FakeBuilder) Named(arg1 string) k8s.Builder {
fake.namedMutex.Lock()
ret, specificReturn := fake.namedReturnsOnCall[len(fake.namedArgsForCall)]
fake.namedArgsForCall = append(fake.namedArgsForCall, struct {
arg1 string
}{arg1})
stub := fake.NamedStub
fakeReturns := fake.namedReturns
fake.recordInvocation("Named", []interface{}{arg1})
fake.namedMutex.Unlock()
if stub != nil {
return stub(arg1)
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *FakeBuilder) NamedCallCount() int {
fake.namedMutex.RLock()
defer fake.namedMutex.RUnlock()
return len(fake.namedArgsForCall)
}
func (fake *FakeBuilder) NamedCalls(stub func(string) k8s.Builder) {
fake.namedMutex.Lock()
defer fake.namedMutex.Unlock()
fake.NamedStub = stub
}
func (fake *FakeBuilder) NamedArgsForCall(i int) string {
fake.namedMutex.RLock()
defer fake.namedMutex.RUnlock()
argsForCall := fake.namedArgsForCall[i]
return argsForCall.arg1
}
func (fake *FakeBuilder) NamedReturns(result1 k8s.Builder) {
fake.namedMutex.Lock()
defer fake.namedMutex.Unlock()
fake.NamedStub = nil
fake.namedReturns = struct {
result1 k8s.Builder
}{result1}
}
func (fake *FakeBuilder) NamedReturnsOnCall(i int, result1 k8s.Builder) {
fake.namedMutex.Lock()
defer fake.namedMutex.Unlock()
fake.NamedStub = nil
if fake.namedReturnsOnCall == nil {
fake.namedReturnsOnCall = make(map[int]struct {
result1 k8s.Builder
})
}
fake.namedReturnsOnCall[i] = struct {
result1 k8s.Builder
}{result1}
}
func (fake *FakeBuilder) Owns(arg1 client.Object, arg2 ...builder.OwnsOption) k8s.Builder {
fake.ownsMutex.Lock()
ret, specificReturn := fake.ownsReturnsOnCall[len(fake.ownsArgsForCall)]
fake.ownsArgsForCall = append(fake.ownsArgsForCall, struct {
arg1 client.Object
arg2 []builder.OwnsOption
}{arg1, arg2})
stub := fake.OwnsStub
fakeReturns := fake.ownsReturns
fake.recordInvocation("Owns", []interface{}{arg1, arg2})
fake.ownsMutex.Unlock()
if stub != nil {
return stub(arg1, arg2...)
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *FakeBuilder) OwnsCallCount() int {
fake.ownsMutex.RLock()
defer fake.ownsMutex.RUnlock()
return len(fake.ownsArgsForCall)
}
func (fake *FakeBuilder) OwnsCalls(stub func(client.Object, ...builder.OwnsOption) k8s.Builder) {
fake.ownsMutex.Lock()
defer fake.ownsMutex.Unlock()
fake.OwnsStub = stub
}
func (fake *FakeBuilder) OwnsArgsForCall(i int) (client.Object, []builder.OwnsOption) {
fake.ownsMutex.RLock()
defer fake.ownsMutex.RUnlock()
argsForCall := fake.ownsArgsForCall[i]
return argsForCall.arg1, argsForCall.arg2
}
func (fake *FakeBuilder) OwnsReturns(result1 k8s.Builder) {
fake.ownsMutex.Lock()
defer fake.ownsMutex.Unlock()
fake.OwnsStub = nil
fake.ownsReturns = struct {
result1 k8s.Builder
}{result1}
}
func (fake *FakeBuilder) OwnsReturnsOnCall(i int, result1 k8s.Builder) {
fake.ownsMutex.Lock()
defer fake.ownsMutex.Unlock()
fake.OwnsStub = nil
if fake.ownsReturnsOnCall == nil {
fake.ownsReturnsOnCall = make(map[int]struct {
result1 k8s.Builder
})
}
fake.ownsReturnsOnCall[i] = struct {
result1 k8s.Builder
}{result1}
}
func (fake *FakeBuilder) WithEventFilter(arg1 predicate.Predicate) k8s.Builder {
fake.withEventFilterMutex.Lock()
ret, specificReturn := fake.withEventFilterReturnsOnCall[len(fake.withEventFilterArgsForCall)]
fake.withEventFilterArgsForCall = append(fake.withEventFilterArgsForCall, struct {
arg1 predicate.Predicate
}{arg1})
stub := fake.WithEventFilterStub
fakeReturns := fake.withEventFilterReturns
fake.recordInvocation("WithEventFilter", []interface{}{arg1})
fake.withEventFilterMutex.Unlock()
if stub != nil {
return stub(arg1)
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *FakeBuilder) WithEventFilterCallCount() int {
fake.withEventFilterMutex.RLock()
defer fake.withEventFilterMutex.RUnlock()
return len(fake.withEventFilterArgsForCall)
}
func (fake *FakeBuilder) WithEventFilterCalls(stub func(predicate.Predicate) k8s.Builder) {
fake.withEventFilterMutex.Lock()
defer fake.withEventFilterMutex.Unlock()
fake.WithEventFilterStub = stub
}
func (fake *FakeBuilder) WithEventFilterArgsForCall(i int) predicate.Predicate {
fake.withEventFilterMutex.RLock()
defer fake.withEventFilterMutex.RUnlock()
argsForCall := fake.withEventFilterArgsForCall[i]
return argsForCall.arg1
}
func (fake *FakeBuilder) WithEventFilterReturns(result1 k8s.Builder) {
fake.withEventFilterMutex.Lock()
defer fake.withEventFilterMutex.Unlock()
fake.WithEventFilterStub = nil
fake.withEventFilterReturns = struct {
result1 k8s.Builder
}{result1}
}
func (fake *FakeBuilder) WithEventFilterReturnsOnCall(i int, result1 k8s.Builder) {
fake.withEventFilterMutex.Lock()
defer fake.withEventFilterMutex.Unlock()
fake.WithEventFilterStub = nil
if fake.withEventFilterReturnsOnCall == nil {
fake.withEventFilterReturnsOnCall = make(map[int]struct {
result1 k8s.Builder
})
}
fake.withEventFilterReturnsOnCall[i] = struct {
result1 k8s.Builder
}{result1}
}
func (fake *FakeBuilder) WithLogger(arg1 logr.Logger) k8s.Builder {
fake.withLoggerMutex.Lock()
ret, specificReturn := fake.withLoggerReturnsOnCall[len(fake.withLoggerArgsForCall)]
fake.withLoggerArgsForCall = append(fake.withLoggerArgsForCall, struct {
arg1 logr.Logger
}{arg1})
stub := fake.WithLoggerStub
fakeReturns := fake.withLoggerReturns
fake.recordInvocation("WithLogger", []interface{}{arg1})
fake.withLoggerMutex.Unlock()
if stub != nil {
return stub(arg1)
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *FakeBuilder) WithLoggerCallCount() int {
fake.withLoggerMutex.RLock()
defer fake.withLoggerMutex.RUnlock()
return len(fake.withLoggerArgsForCall)
}
func (fake *FakeBuilder) WithLoggerCalls(stub func(logr.Logger) k8s.Builder) {
fake.withLoggerMutex.Lock()
defer fake.withLoggerMutex.Unlock()
fake.WithLoggerStub = stub
}
func (fake *FakeBuilder) WithLoggerArgsForCall(i int) logr.Logger {
fake.withLoggerMutex.RLock()
defer fake.withLoggerMutex.RUnlock()
argsForCall := fake.withLoggerArgsForCall[i]
return argsForCall.arg1
}
func (fake *FakeBuilder) WithLoggerReturns(result1 k8s.Builder) {
fake.withLoggerMutex.Lock()
defer fake.withLoggerMutex.Unlock()
fake.WithLoggerStub = nil
fake.withLoggerReturns = struct {
result1 k8s.Builder
}{result1}
}
func (fake *FakeBuilder) WithLoggerReturnsOnCall(i int, result1 k8s.Builder) {
fake.withLoggerMutex.Lock()
defer fake.withLoggerMutex.Unlock()
fake.WithLoggerStub = nil
if fake.withLoggerReturnsOnCall == nil {
fake.withLoggerReturnsOnCall = make(map[int]struct {
result1 k8s.Builder
})
}
fake.withLoggerReturnsOnCall[i] = struct {
result1 k8s.Builder
}{result1}
}
func (fake *FakeBuilder) WithOptions(arg1 controller.Options) k8s.Builder {
fake.withOptionsMutex.Lock()
ret, specificReturn := fake.withOptionsReturnsOnCall[len(fake.withOptionsArgsForCall)]
fake.withOptionsArgsForCall = append(fake.withOptionsArgsForCall, struct {
arg1 controller.Options
}{arg1})
stub := fake.WithOptionsStub
fakeReturns := fake.withOptionsReturns
fake.recordInvocation("WithOptions", []interface{}{arg1})
fake.withOptionsMutex.Unlock()
if stub != nil {
return stub(arg1)
}
if specificReturn {
return ret.result1
}
return fakeReturns.result1
}
func (fake *FakeBuilder) WithOptionsCallCount() int {
fake.withOptionsMutex.RLock()
defer fake.withOptionsMutex.RUnlock()
return len(fake.withOptionsArgsForCall)
}
func (fake *FakeBuilder) WithOptionsCalls(stub func(controller.Options) k8s.Builder) {
fake.withOptionsMutex.Lock()
defer fake.withOptionsMutex.Unlock()
fake.WithOptionsStub = stub
}
func (fake *FakeBuilder) WithOptionsArgsForCall(i int) controller.Options {
fake.withOptionsMutex.RLock()
defer fake.withOptionsMutex.RUnlock()
argsForCall := fake.withOptionsArgsForCall[i]
return argsForCall.arg1
}
func (fake *FakeBuilder) WithOptionsReturns(result1 k8s.Builder) {
fake.withOptionsMutex.Lock()
defer fake.withOptionsMutex.Unlock()
fake.WithOptionsStub = nil
fake.withOptionsReturns = struct {
result1 k8s.Builder
}{result1}
}
func (fake *FakeBuilder) WithOptionsReturnsOnCall(i int, result1 k8s.Builder) {
fake.withOptionsMutex.Lock()
defer fake.withOptionsMutex.Unlock()
fake.WithOptionsStub = nil
if fake.withOptionsReturnsOnCall == nil {
fake.withOptionsReturnsOnCall = make(map[int]struct {
result1 k8s.Builder
})
}
fake.withOptionsReturnsOnCall[i] = struct {
result1 k8s.Builder
}{result1}
}
func (fake *FakeBuilder) Invocations() map[string][][]interface{} {
fake.invocationsMutex.RLock()
defer fake.invocationsMutex.RUnlock()
fake.buildMutex.RLock()
defer fake.buildMutex.RUnlock()
fake.completeMutex.RLock()
defer fake.completeMutex.RUnlock()
fake.forMutex.RLock()
defer fake.forMutex.RUnlock()
fake.namedMutex.RLock()
defer fake.namedMutex.RUnlock()
fake.ownsMutex.RLock()
defer fake.ownsMutex.RUnlock()
fake.withEventFilterMutex.RLock()
defer fake.withEventFilterMutex.RUnlock()
fake.withLoggerMutex.RLock()
defer fake.withLoggerMutex.RUnlock()
fake.withOptionsMutex.RLock()
defer fake.withOptionsMutex.RUnlock()
copiedInvocations := map[string][][]interface{}{}
for key, value := range fake.invocations {
copiedInvocations[key] = value
}
return copiedInvocations
}
func (fake *FakeBuilder) recordInvocation(key string, args []interface{}) {
fake.invocationsMutex.Lock()
defer fake.invocationsMutex.Unlock()
if fake.invocations == nil {
fake.invocations = map[string][][]interface{}{}
}
if fake.invocations[key] == nil {
fake.invocations[key] = [][]interface{}{}
}
fake.invocations[key] = append(fake.invocations[key], args)
}
var _ k8s.Builder = new(FakeBuilder)
Write Preview
Loading…
Cancel
Save