diff --git a/vars/build_vars.go b/vars/build_vars.go new file mode 100644 index 000000000..22ff198d9 --- /dev/null +++ b/vars/build_vars.go @@ -0,0 +1,69 @@ +package vars + +type BuildVariables struct { + parentScope interface { + Variables + IterateInterpolatedCreds(iter TrackedVarsIterator) + } + + localVars StaticVariables + tracker *tracker +} + +func NewBuildVariables(credVars Variables, enableRedaction bool) *BuildVariables { + return &BuildVariables{ + parentScope: &credVarsTracker{ + credVars: credVars, + tracker: newTracker(enableRedaction), + }, + localVars: StaticVariables{}, + tracker: newTracker(enableRedaction), + } +} + +func (b *BuildVariables) Get(varDef VariableDefinition) (interface{}, bool, error) { + if varDef.Ref.Source == "." { + val, found, _ := b.localVars.Get(varDef) + if found { + return val, true, nil + } + } + return b.parentScope.Get(varDef) +} + +func (b *BuildVariables) List() ([]VariableDefinition, error) { + list, err := b.parentScope.List() + if err != nil { + return nil, err + } + for k := range b.localVars { + list = append(list, VariableDefinition{ + Ref: VariableReference{Source: ".", Path: k}, + }) + } + return list, nil +} + +func (b *BuildVariables) IterateInterpolatedCreds(iter TrackedVarsIterator) { + b.tracker.IterateInterpolatedCreds(iter) + b.parentScope.IterateInterpolatedCreds(iter) +} + +func (b *BuildVariables) NewLocalScope() *BuildVariables { + return &BuildVariables{ + parentScope: b, + localVars: StaticVariables{}, + tracker: newTracker(b.tracker.enabled), + } +} + +func (b *BuildVariables) AddLocalVar(name string, val interface{}, redact bool) { + b.localVars[name] = val + if redact { + b.tracker.Track(VariableReference{Source: ".", Path: name}, val) + } +} + +func (b *BuildVariables) RedactionEnabled() bool { + return b.tracker.enabled +} diff --git a/vars/build_vars_test.go b/vars/build_vars_test.go new file mode 100644 index 000000000..f9014ddbc --- /dev/null +++ b/vars/build_vars_test.go @@ -0,0 +1,195 @@ +package vars_test + +import ( + "github.com/concourse/concourse/vars" + . "github.com/concourse/concourse/vars" + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +var _ = Describe("BuildVariables", func() { + var buildVars *vars.BuildVariables + + Describe("turn on track", func() { + BeforeEach(func() { + buildVars = vars.NewBuildVariables(StaticVariables{"k1": "v1", "k2": "v2", "k3": "v3"}, true) + }) + + Describe("Get", func() { + It("returns expected value", func() { + val, found, err := buildVars.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}}) + Expect(found).To(BeTrue()) + Expect(err).To(BeNil()) + Expect(val).To(Equal("v1")) + }) + + It("fetched variables are tracked", func() { + buildVars.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}}) + buildVars.Get(VariableDefinition{Ref: VariableReference{Path: "k2"}}) + mapit := vars.TrackedVarsMap{} + buildVars.IterateInterpolatedCreds(mapit) + Expect(mapit["k1"]).To(Equal("v1")) + Expect(mapit["k2"]).To(Equal("v2")) + // "k3" has not been Get, thus should not be tracked. + Expect(mapit).ToNot(HaveKey("k3")) + }) + }) + + Describe("List", func() { + It("returns list of names from multiple vars with duplicates", func() { + defs, err := buildVars.List() + Expect(defs).To(ConsistOf([]VariableDefinition{ + {Ref: VariableReference{Path: "k1"}}, + {Ref: VariableReference{Path: "k2"}}, + {Ref: VariableReference{Path: "k3"}}, + })) + Expect(err).ToNot(HaveOccurred()) + }) + + It("includes all local vars", func() { + buildVars.AddLocalVar("l1", 1, false) + buildVars.AddLocalVar("l2", 2, false) + + defs, err := buildVars.List() + Expect(defs).To(ConsistOf([]VariableDefinition{ + {Ref: VariableReference{Source: ".", Path: "l1"}}, + {Ref: VariableReference{Source: ".", Path: "l2"}}, + + {Ref: VariableReference{Path: "k1"}}, + {Ref: VariableReference{Path: "k2"}}, + {Ref: VariableReference{Path: "k3"}}, + })) + Expect(err).ToNot(HaveOccurred()) + }) + }) + + Describe("AddLocalVar", func() { + Describe("redact", func() { + BeforeEach(func() { + buildVars.AddLocalVar("foo", "bar", true) + }) + + It("should get local value", func() { + val, found, err := buildVars.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "foo"}}) + Expect(err).To(BeNil()) + Expect(found).To(BeTrue()) + Expect(val).To(Equal("bar")) + }) + + It("fetched variables are tracked when added", func() { + mapit := vars.TrackedVarsMap{} + buildVars.IterateInterpolatedCreds(mapit) + Expect(mapit["foo"]).To(Equal("bar")) + }) + }) + }) + + Describe("NewLocalScope", func() { + It("can access local vars from parent scope", func() { + buildVars.AddLocalVar("hello", "world", false) + scope := buildVars.NewLocalScope() + val, _, _ := scope.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "hello"}}) + Expect(val).To(Equal("world")) + }) + + It("adding local vars does not affect the original tracker", func() { + scope := buildVars.NewLocalScope() + scope.AddLocalVar("hello", "world", false) + _, found, _ := buildVars.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "hello"}}) + Expect(found).To(BeFalse()) + }) + + It("shares the underlying non-local variables", func() { + scope := buildVars.NewLocalScope() + val, _, _ := scope.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}}) + Expect(val).To(Equal("v1")) + }) + + It("local vars added after creating the subscope are accessible", func() { + scope := buildVars.NewLocalScope() + buildVars.AddLocalVar("hello", "world", false) + val, _, _ := scope.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "hello"}}) + Expect(val).To(Equal("world")) + }) + + It("current scope is preferred over parent scope", func() { + buildVars.AddLocalVar("a", 1, false) + scope := buildVars.NewLocalScope() + scope.AddLocalVar("a", 2, false) + + val, _, _ := scope.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "a"}}) + Expect(val).To(Equal(2)) + }) + + Describe("TrackedVarsMap", func() { + It("prefers the value set in the current scope over the parent scope", func() { + buildVars.AddLocalVar("a", "from parent", true) + scope := buildVars.NewLocalScope() + scope.AddLocalVar("a", "from child", true) + + mapit := vars.TrackedVarsMap{} + scope.IterateInterpolatedCreds(mapit) + + Expect(mapit["a"]).To(Equal("from child")) + }) + }) + }) + + Describe("not redact", func() { + BeforeEach(func() { + buildVars.AddLocalVar("foo", "bar", false) + }) + + It("should get local value", func() { + val, found, err := buildVars.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "foo"}}) + Expect(err).To(BeNil()) + Expect(found).To(BeTrue()) + Expect(val).To(Equal("bar")) + }) + + It("fetched variables are not tracked", func() { + buildVars.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "foo"}}) + mapit := vars.TrackedVarsMap{} + buildVars.IterateInterpolatedCreds(mapit) + Expect(mapit).ToNot(ContainElement("foo")) + }) + }) + }) + + Describe("turn off track", func() { + BeforeEach(func() { + buildVars = vars.NewBuildVariables(StaticVariables{"k1": "v1", "k2": "v2", "k3": "v3"}, false) + }) + + Describe("Get", func() { + It("returns expected value", func() { + val, found, err := buildVars.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}}) + Expect(found).To(BeTrue()) + Expect(err).To(BeNil()) + Expect(val).To(Equal("v1")) + }) + + It("fetched variables should not be tracked", func() { + buildVars.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}}) + buildVars.Get(VariableDefinition{Ref: VariableReference{Path: "k2"}}) + mapit := vars.TrackedVarsMap{} + buildVars.IterateInterpolatedCreds(mapit) + Expect(mapit).ToNot(HaveKey("k1")) + Expect(mapit).ToNot(HaveKey("k2")) + Expect(mapit).ToNot(HaveKey("k3")) + }) + }) + + Describe("List", func() { + It("returns list of names from multiple vars with duplicates", func() { + defs, err := buildVars.List() + Expect(defs).To(ConsistOf([]VariableDefinition{ + {Ref: VariableReference{Path: "k1"}}, + {Ref: VariableReference{Path: "k2"}}, + {Ref: VariableReference{Path: "k3"}}, + })) + Expect(err).ToNot(HaveOccurred()) + }) + }) + }) +}) diff --git a/vars/tracker.go b/vars/tracker.go new file mode 100644 index 000000000..02846de75 --- /dev/null +++ b/vars/tracker.go @@ -0,0 +1,97 @@ +package vars + +import ( + "strings" + "sync" +) + +type TrackedVarsIterator interface { + YieldCred(string, string) +} + +type tracker struct { + enabled bool + + // Considering in-parallel steps, a lock is need. + lock sync.RWMutex + interpolatedCreds map[string]string +} + +func newTracker(on bool) *tracker { + return &tracker{ + enabled: on, + interpolatedCreds: map[string]string{}, + } +} + +func (t *tracker) Track(varRef VariableReference, val interface{}) { + if !t.enabled { + return + } + + t.lock.Lock() + defer t.lock.Unlock() + + t.track(varRef, val) +} + +func (t *tracker) track(varRef VariableReference, val interface{}) { + switch v := val.(type) { + case map[interface{}]interface{}: + for kk, vv := range v { + t.track(VariableReference{ + Path: varRef.Path, + Fields: append(varRef.Fields, kk.(string)), + }, vv) + } + case map[string]interface{}: + for kk, vv := range v { + t.track(VariableReference{ + Path: varRef.Path, + Fields: append(varRef.Fields, kk), + }, vv) + } + case string: + paths := append([]string{varRef.Path}, varRef.Fields...) + + t.interpolatedCreds[strings.Join(paths, ".")] = v + default: + // Do nothing + } +} + +func (t *tracker) IterateInterpolatedCreds(iter TrackedVarsIterator) { + t.lock.RLock() + for k, v := range t.interpolatedCreds { + iter.YieldCred(k, v) + } + t.lock.RUnlock() +} + +type credVarsTracker struct { + *tracker + credVars Variables +} + +func (t *credVarsTracker) Get(varDef VariableDefinition) (interface{}, bool, error) { + val, found, err := t.credVars.Get(varDef) + if found { + t.tracker.Track(varDef.Ref, val) + } + return val, found, err +} + +func (t *credVarsTracker) List() ([]VariableDefinition, error) { + return t.credVars.List() +} + +// TrackedVarsMap is a TrackedVarsIterator which populates interpolated secrets into a map. +// If there are multiple secrets with the same name, it only keeps the first value. +type TrackedVarsMap map[string]string + +func (it TrackedVarsMap) YieldCred(k, v string) { + _, found := it[k] + if !found { + it[k] = v + } +} diff --git a/vars/variables.go b/vars/variables.go index 5eff04d78..2874a5329 100644 --- a/vars/variables.go +++ b/vars/variables.go @@ -1,5 +1,7 @@ package vars +//go:generate counterfeiter . Variables + type Variables interface { Get(VariableDefinition) (interface{}, bool, error) List() ([]VariableDefinition, error) diff --git a/vars/vars_tracker.go b/vars/vars_tracker.go deleted file mode 100644 index 657b705a5..000000000 --- a/vars/vars_tracker.go +++ /dev/null @@ -1,152 +0,0 @@ -package vars - -import ( - "strings" - "sync" -) - -// CredVarsTracker implements the interface Variables. It wraps a secret manager and -// tracks key-values fetched from the secret managers. It also provides a method to -// thread-safely iterate interpolated key-values. -type CredVarsTrackerIterator interface { - YieldCred(string, string) -} - -//go:generate counterfeiter . CredVarsTracker - -type CredVarsTracker interface { - Variables - IterateInterpolatedCreds(iter CredVarsTrackerIterator) - Enabled() bool - - NewLocalScope() CredVarsTracker - AddLocalVar(string, interface{}, bool) -} - -func NewCredVarsTracker(credVars Variables, on bool) CredVarsTracker { - return &credVarsTracker{ - localVars: StaticVariables{}, - credVars: credVars, - enabled: on, - interpolatedCreds: map[string]string{}, - noRedactVarNames: map[string]bool{}, - } -} - -type credVarsTracker struct { - credVars Variables - localVars StaticVariables - - enabled bool - - interpolatedCreds map[string]string - - noRedactVarNames map[string]bool - - // Considering in-parallel steps, a lock is need. - lock sync.RWMutex -} - -func (t *credVarsTracker) Get(varDef VariableDefinition) (interface{}, bool, error) { - var ( - val interface{} - found bool - err error - ) - - redact := true - if varDef.Ref.Source == "." { - val, found, err = t.localVars.Get(varDef) - if found { - if _, ok := t.noRedactVarNames[varDef.Ref.Path]; ok { - redact = false - } - } - } else { - val, found, err = t.credVars.Get(varDef) - } - - if t.enabled && found && redact { - t.lock.Lock() - t.track(varDef.Ref, val) - t.lock.Unlock() - } - - return val, found, err -} - -func (t *credVarsTracker) track(varRef VariableReference, val interface{}) { - switch v := val.(type) { - case map[interface{}]interface{}: - for kk, vv := range v { - t.track(VariableReference{ - Path: varRef.Path, - Fields: append(varRef.Fields, kk.(string)), - }, vv) - } - case map[string]interface{}: - for kk, vv := range v { - t.track(VariableReference{ - Path: varRef.Path, - Fields: append(varRef.Fields, kk), - }, vv) - } - case string: - paths := append([]string{varRef.Path}, varRef.Fields...) - - t.interpolatedCreds[strings.Join(paths, ".")] = v - default: - // Do nothing - } -} - -func (t *credVarsTracker) List() ([]VariableDefinition, error) { - return t.credVars.List() -} - -func (t *credVarsTracker) IterateInterpolatedCreds(iter CredVarsTrackerIterator) { - t.lock.RLock() - for k, v := range t.interpolatedCreds { - iter.YieldCred(k, v) - } - t.lock.RUnlock() -} - -func (t *credVarsTracker) Enabled() bool { - return t.enabled -} - -func (t *credVarsTracker) NewLocalScope() CredVarsTracker { - localVarsClone := make(StaticVariables, len(t.localVars)) - for k, v := range t.localVars { - localVarsClone[k] = v - } - noRedactVarNamesClone := make(map[string]bool, len(t.noRedactVarNames)) - for k, v := range t.noRedactVarNames { - noRedactVarNamesClone[k] = v - } - interpolatedCredsClone := MapCredVarsTrackerIterator{} - t.IterateInterpolatedCreds(interpolatedCredsClone) - return &credVarsTracker{ - credVars: t.credVars, - enabled: t.enabled, - localVars: localVarsClone, - noRedactVarNames: noRedactVarNamesClone, - interpolatedCreds: interpolatedCredsClone, - } -} - -func (t *credVarsTracker) AddLocalVar(name string, value interface{}, redact bool) { - t.localVars[name] = value - if !redact { - t.noRedactVarNames[name] = true - } -} - -// MapCredVarsTrackerIterator implements a simple CredVarsTrackerIterator which just -// populate interpolated secrets into a map. -type MapCredVarsTrackerIterator map[string]string - -func (it MapCredVarsTrackerIterator) YieldCred(k, v string) { - it[k] = v -} diff --git a/vars/vars_tracker_test.go b/vars/vars_tracker_test.go deleted file mode 100644 index 438036bac..000000000 --- a/vars/vars_tracker_test.go +++ /dev/null @@ -1,172 +0,0 @@ -package vars_test - -import ( - . "github.com/concourse/concourse/vars" - . "github.com/onsi/ginkgo" - . "github.com/onsi/gomega" -) - -var _ = Describe("vars_tracker", func() { - var tracker CredVarsTracker - - Describe("turn on track", func() { - BeforeEach(func() { - v := StaticVariables{"k1": "v1", "k2": "v2", "k3": "v3"} - tracker = NewCredVarsTracker(v, true) - }) - - Describe("Get", func() { - It("returns expected value", func() { - var ( - val interface{} - found bool - err error - ) - val, found, err = tracker.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}}) - Expect(found).To(BeTrue()) - Expect(err).To(BeNil()) - Expect(val).To(Equal("v1")) - }) - - It("fetched variables are tracked", func() { - tracker.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}}) - tracker.Get(VariableDefinition{Ref: VariableReference{Path: "k2"}}) - mapit := MapCredVarsTrackerIterator{} - tracker.IterateInterpolatedCreds(mapit) - Expect(mapit["k1"]).To(Equal("v1")) - Expect(mapit["k2"]).To(Equal("v2")) - // "k3" has not been Get, thus should not be tracked. - Expect(mapit).ToNot(ContainElement("k3")) - }) - }) - - Describe("List", func() { - It("returns list of names from multiple vars with duplicates", func() { - defs, err := tracker.List() - Expect(defs).To(ConsistOf([]VariableDefinition{ - {Ref: VariableReference{Path: "k1"}}, - {Ref: VariableReference{Path: "k2"}}, - {Ref: VariableReference{Path: "k3"}}, - })) - Expect(err).ToNot(HaveOccurred()) - }) - }) - - Describe("AddLocalVar", func() { - Describe("redact", func() { - BeforeEach(func() { - tracker.AddLocalVar("foo", "bar", true) - }) - - It("should get local value", func() { - var ( - val interface{} - found bool - err error - ) - val, found, err = tracker.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "foo"}}) - Expect(err).To(BeNil()) - Expect(found).To(BeTrue()) - Expect(val).To(Equal("bar")) - }) - - It("fetched variables are tracked", func() { - tracker.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "foo"}}) - mapit := MapCredVarsTrackerIterator{} - tracker.IterateInterpolatedCreds(mapit) - Expect(mapit["foo"]).To(Equal("bar")) - }) - }) - }) - - Describe("NewLocalScope", func() { - It("copies all existing local vars", func() { - tracker.AddLocalVar("hello", "world", false) - scope := tracker.NewLocalScope() - val, _, _ := scope.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "hello"}}) - Expect(val).To(Equal("world")) - }) - - It("adding local vars does not affect the original tracker", func() { - scope := tracker.NewLocalScope() - scope.AddLocalVar("hello", "world", false) - _, found, _ := tracker.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "hello"}}) - Expect(found).To(BeFalse()) - }) - - It("shares the underlying non-local variables", func() { - scope := tracker.NewLocalScope() - val, _, _ := scope.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}}) - Expect(val).To(Equal("v1")) - }) - }) - - Describe("not redact", func() { - BeforeEach(func() { - tracker.AddLocalVar("foo", "bar", false) - }) - - It("should get local value", func() { - var ( - val interface{} - found bool - err error - ) - val, found, err = tracker.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "foo"}}) - Expect(err).To(BeNil()) - Expect(found).To(BeTrue()) - Expect(val).To(Equal("bar")) - }) - - It("fetched variables are not tracked", func() { - tracker.Get(VariableDefinition{Ref: VariableReference{Source: ".", Path: "foo"}}) - mapit := MapCredVarsTrackerIterator{} - tracker.IterateInterpolatedCreds(mapit) - Expect(mapit).ToNot(ContainElement("foo")) - }) - }) - }) - - Describe("turn off track", func() { - BeforeEach(func() { - v := StaticVariables{"k1": "v1", "k2": "v2", "k3": "v3"} - tracker = NewCredVarsTracker(v, false) - }) - - Describe("Get", func() { - It("returns expected value", func() { - var ( - val interface{} - found bool - err error - ) - val, found, err = tracker.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}}) - Expect(found).To(BeTrue()) - Expect(err).To(BeNil()) - Expect(val).To(Equal("v1")) - }) - - It("fetched variables should not be tracked", func() { - tracker.Get(VariableDefinition{Ref: VariableReference{Path: "k1"}}) - tracker.Get(VariableDefinition{Ref: VariableReference{Path: "k2"}}) - mapit := MapCredVarsTrackerIterator{} - tracker.IterateInterpolatedCreds(mapit) - Expect(mapit).ToNot(ContainElement("k1")) - Expect(mapit).ToNot(ContainElement("k2")) - Expect(mapit).ToNot(ContainElement("k3")) - }) - }) - - Describe("List", func() { - It("returns list of names from multiple vars with duplicates", func() { - defs, err := tracker.List() - Expect(defs).To(ConsistOf([]VariableDefinition{ - {Ref: VariableReference{Path: "k1"}}, - {Ref: VariableReference{Path: "k2"}}, - {Ref: VariableReference{Path: "k3"}}, - })) - Expect(err).ToNot(HaveOccurred()) - }) - }) - }) -}) diff --git a/vars/varsfakes/fake_cred_vars_tracker.go b/vars/varsfakes/fake_cred_vars_tracker.go deleted file mode 100644 index 4d7c0af74..000000000 --- a/vars/varsfakes/fake_cred_vars_tracker.go +++ /dev/null @@ -1,397 +0,0 @@ -// Code generated by counterfeiter. DO NOT EDIT. -package varsfakes - -import ( - "sync" - - "github.com/concourse/concourse/vars" -) - -type FakeCredVarsTracker struct { - AddLocalVarStub func(string, interface{}, bool) - addLocalVarMutex sync.RWMutex - addLocalVarArgsForCall []struct { - arg1 string - arg2 interface{} - arg3 bool - } - EnabledStub func() bool - enabledMutex sync.RWMutex - enabledArgsForCall []struct { - } - enabledReturns struct { - result1 bool - } - enabledReturnsOnCall map[int]struct { - result1 bool - } - GetStub func(vars.VariableDefinition) (interface{}, bool, error) - getMutex sync.RWMutex - getArgsForCall []struct { - arg1 vars.VariableDefinition - } - getReturns struct { - result1 interface{} - result2 bool - result3 error - } - getReturnsOnCall map[int]struct { - result1 interface{} - result2 bool - result3 error - } - IterateInterpolatedCredsStub func(vars.CredVarsTrackerIterator) - iterateInterpolatedCredsMutex sync.RWMutex - iterateInterpolatedCredsArgsForCall []struct { - arg1 vars.CredVarsTrackerIterator - } - ListStub func() ([]vars.VariableDefinition, error) - listMutex sync.RWMutex - listArgsForCall []struct { - } - listReturns struct { - result1 []vars.VariableDefinition - result2 error - } - listReturnsOnCall map[int]struct { - result1 []vars.VariableDefinition - result2 error - } - NewLocalScopeStub func() vars.CredVarsTracker - newLocalScopeMutex sync.RWMutex - newLocalScopeArgsForCall []struct { - } - newLocalScopeReturns struct { - result1 vars.CredVarsTracker - } - newLocalScopeReturnsOnCall map[int]struct { - result1 vars.CredVarsTracker - } - invocations map[string][][]interface{} - invocationsMutex sync.RWMutex -} - -func (fake *FakeCredVarsTracker) AddLocalVar(arg1 string, arg2 interface{}, arg3 bool) { - fake.addLocalVarMutex.Lock() - fake.addLocalVarArgsForCall = append(fake.addLocalVarArgsForCall, struct { - arg1 string - arg2 interface{} - arg3 bool - }{arg1, arg2, arg3}) - fake.recordInvocation("AddLocalVar", []interface{}{arg1, arg2, arg3}) - fake.addLocalVarMutex.Unlock() - if fake.AddLocalVarStub != nil { - fake.AddLocalVarStub(arg1, arg2, arg3) - } -} - -func (fake *FakeCredVarsTracker) AddLocalVarCallCount() int { - fake.addLocalVarMutex.RLock() - defer fake.addLocalVarMutex.RUnlock() - return len(fake.addLocalVarArgsForCall) -} - -func (fake *FakeCredVarsTracker) AddLocalVarCalls(stub func(string, interface{}, bool)) { - fake.addLocalVarMutex.Lock() - defer fake.addLocalVarMutex.Unlock() - fake.AddLocalVarStub = stub -} - -func (fake *FakeCredVarsTracker) AddLocalVarArgsForCall(i int) (string, interface{}, bool) { - fake.addLocalVarMutex.RLock() - defer fake.addLocalVarMutex.RUnlock() - argsForCall := fake.addLocalVarArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeCredVarsTracker) Enabled() bool { - fake.enabledMutex.Lock() - ret, specificReturn := fake.enabledReturnsOnCall[len(fake.enabledArgsForCall)] - fake.enabledArgsForCall = append(fake.enabledArgsForCall, struct { - }{}) - fake.recordInvocation("Enabled", []interface{}{}) - fake.enabledMutex.Unlock() - if fake.EnabledStub != nil { - return fake.EnabledStub() - } - if specificReturn { - return ret.result1 - } - fakeReturns := fake.enabledReturns - return fakeReturns.result1 -} - -func (fake *FakeCredVarsTracker) EnabledCallCount() int { - fake.enabledMutex.RLock() - defer fake.enabledMutex.RUnlock() - return len(fake.enabledArgsForCall) -} - -func (fake *FakeCredVarsTracker) EnabledCalls(stub func() bool) { - fake.enabledMutex.Lock() - defer fake.enabledMutex.Unlock() - fake.EnabledStub = stub -} - -func (fake *FakeCredVarsTracker) EnabledReturns(result1 bool) { - fake.enabledMutex.Lock() - defer fake.enabledMutex.Unlock() - fake.EnabledStub = nil - fake.enabledReturns = struct { - result1 bool - }{result1} -} - -func (fake *FakeCredVarsTracker) EnabledReturnsOnCall(i int, result1 bool) { - fake.enabledMutex.Lock() - defer fake.enabledMutex.Unlock() - fake.EnabledStub = nil - if fake.enabledReturnsOnCall == nil { - fake.enabledReturnsOnCall = make(map[int]struct { - result1 bool - }) - } - fake.enabledReturnsOnCall[i] = struct { - result1 bool - }{result1} -} - -func (fake *FakeCredVarsTracker) Get(arg1 vars.VariableDefinition) (interface{}, bool, error) { - fake.getMutex.Lock() - ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] - fake.getArgsForCall = append(fake.getArgsForCall, struct { - arg1 vars.VariableDefinition - }{arg1}) - fake.recordInvocation("Get", []interface{}{arg1}) - fake.getMutex.Unlock() - if fake.GetStub != nil { - return fake.GetStub(arg1) - } - if specificReturn { - return ret.result1, ret.result2, ret.result3 - } - fakeReturns := fake.getReturns - return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 -} - -func (fake *FakeCredVarsTracker) GetCallCount() int { - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - return len(fake.getArgsForCall) -} - -func (fake *FakeCredVarsTracker) GetCalls(stub func(vars.VariableDefinition) (interface{}, bool, error)) { - fake.getMutex.Lock() - defer fake.getMutex.Unlock() - fake.GetStub = stub -} - -func (fake *FakeCredVarsTracker) GetArgsForCall(i int) vars.VariableDefinition { - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - argsForCall := fake.getArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeCredVarsTracker) GetReturns(result1 interface{}, result2 bool, result3 error) { - fake.getMutex.Lock() - defer fake.getMutex.Unlock() - fake.GetStub = nil - fake.getReturns = struct { - result1 interface{} - result2 bool - result3 error - }{result1, result2, result3} -} - -func (fake *FakeCredVarsTracker) GetReturnsOnCall(i int, result1 interface{}, result2 bool, result3 error) { - fake.getMutex.Lock() - defer fake.getMutex.Unlock() - fake.GetStub = nil - if fake.getReturnsOnCall == nil { - fake.getReturnsOnCall = make(map[int]struct { - result1 interface{} - result2 bool - result3 error - }) - } - fake.getReturnsOnCall[i] = struct { - result1 interface{} - result2 bool - result3 error - }{result1, result2, result3} -} - -func (fake *FakeCredVarsTracker) IterateInterpolatedCreds(arg1 vars.CredVarsTrackerIterator) { - fake.iterateInterpolatedCredsMutex.Lock() - fake.iterateInterpolatedCredsArgsForCall = append(fake.iterateInterpolatedCredsArgsForCall, struct { - arg1 vars.CredVarsTrackerIterator - }{arg1}) - fake.recordInvocation("IterateInterpolatedCreds", []interface{}{arg1}) - fake.iterateInterpolatedCredsMutex.Unlock() - if fake.IterateInterpolatedCredsStub != nil { - fake.IterateInterpolatedCredsStub(arg1) - } -} - -func (fake *FakeCredVarsTracker) IterateInterpolatedCredsCallCount() int { - fake.iterateInterpolatedCredsMutex.RLock() - defer fake.iterateInterpolatedCredsMutex.RUnlock() - return len(fake.iterateInterpolatedCredsArgsForCall) -} - -func (fake *FakeCredVarsTracker) IterateInterpolatedCredsCalls(stub func(vars.CredVarsTrackerIterator)) { - fake.iterateInterpolatedCredsMutex.Lock() - defer fake.iterateInterpolatedCredsMutex.Unlock() - fake.IterateInterpolatedCredsStub = stub -} - -func (fake *FakeCredVarsTracker) IterateInterpolatedCredsArgsForCall(i int) vars.CredVarsTrackerIterator { - fake.iterateInterpolatedCredsMutex.RLock() - defer fake.iterateInterpolatedCredsMutex.RUnlock() - argsForCall := fake.iterateInterpolatedCredsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeCredVarsTracker) List() ([]vars.VariableDefinition, error) { - fake.listMutex.Lock() - ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] - fake.listArgsForCall = append(fake.listArgsForCall, struct { - }{}) - fake.recordInvocation("List", []interface{}{}) - fake.listMutex.Unlock() - if fake.ListStub != nil { - return fake.ListStub() - } - if specificReturn { - return ret.result1, ret.result2 - } - fakeReturns := fake.listReturns - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeCredVarsTracker) ListCallCount() int { - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - return len(fake.listArgsForCall) -} - -func (fake *FakeCredVarsTracker) ListCalls(stub func() ([]vars.VariableDefinition, error)) { - fake.listMutex.Lock() - defer fake.listMutex.Unlock() - fake.ListStub = stub -} - -func (fake *FakeCredVarsTracker) ListReturns(result1 []vars.VariableDefinition, result2 error) { - fake.listMutex.Lock() - defer fake.listMutex.Unlock() - fake.ListStub = nil - fake.listReturns = struct { - result1 []vars.VariableDefinition - result2 error - }{result1, result2} -} - -func (fake *FakeCredVarsTracker) ListReturnsOnCall(i int, result1 []vars.VariableDefinition, result2 error) { - fake.listMutex.Lock() - defer fake.listMutex.Unlock() - fake.ListStub = nil - if fake.listReturnsOnCall == nil { - fake.listReturnsOnCall = make(map[int]struct { - result1 []vars.VariableDefinition - result2 error - }) - } - fake.listReturnsOnCall[i] = struct { - result1 []vars.VariableDefinition - result2 error - }{result1, result2} -} - -func (fake *FakeCredVarsTracker) NewLocalScope() vars.CredVarsTracker { - fake.newLocalScopeMutex.Lock() - ret, specificReturn := fake.newLocalScopeReturnsOnCall[len(fake.newLocalScopeArgsForCall)] - fake.newLocalScopeArgsForCall = append(fake.newLocalScopeArgsForCall, struct { - }{}) - fake.recordInvocation("NewLocalScope", []interface{}{}) - fake.newLocalScopeMutex.Unlock() - if fake.NewLocalScopeStub != nil { - return fake.NewLocalScopeStub() - } - if specificReturn { - return ret.result1 - } - fakeReturns := fake.newLocalScopeReturns - return fakeReturns.result1 -} - -func (fake *FakeCredVarsTracker) NewLocalScopeCallCount() int { - fake.newLocalScopeMutex.RLock() - defer fake.newLocalScopeMutex.RUnlock() - return len(fake.newLocalScopeArgsForCall) -} - -func (fake *FakeCredVarsTracker) NewLocalScopeCalls(stub func() vars.CredVarsTracker) { - fake.newLocalScopeMutex.Lock() - defer fake.newLocalScopeMutex.Unlock() - fake.NewLocalScopeStub = stub -} - -func (fake *FakeCredVarsTracker) NewLocalScopeReturns(result1 vars.CredVarsTracker) { - fake.newLocalScopeMutex.Lock() - defer fake.newLocalScopeMutex.Unlock() - fake.NewLocalScopeStub = nil - fake.newLocalScopeReturns = struct { - result1 vars.CredVarsTracker - }{result1} -} - -func (fake *FakeCredVarsTracker) NewLocalScopeReturnsOnCall(i int, result1 vars.CredVarsTracker) { - fake.newLocalScopeMutex.Lock() - defer fake.newLocalScopeMutex.Unlock() - fake.NewLocalScopeStub = nil - if fake.newLocalScopeReturnsOnCall == nil { - fake.newLocalScopeReturnsOnCall = make(map[int]struct { - result1 vars.CredVarsTracker - }) - } - fake.newLocalScopeReturnsOnCall[i] = struct { - result1 vars.CredVarsTracker - }{result1} -} - -func (fake *FakeCredVarsTracker) Invocations() map[string][][]interface{} { - fake.invocationsMutex.RLock() - defer fake.invocationsMutex.RUnlock() - fake.addLocalVarMutex.RLock() - defer fake.addLocalVarMutex.RUnlock() - fake.enabledMutex.RLock() - defer fake.enabledMutex.RUnlock() - fake.getMutex.RLock() - defer fake.getMutex.RUnlock() - fake.iterateInterpolatedCredsMutex.RLock() - defer fake.iterateInterpolatedCredsMutex.RUnlock() - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - fake.newLocalScopeMutex.RLock() - defer fake.newLocalScopeMutex.RUnlock() - copiedInvocations := map[string][][]interface{}{} - for key, value := range fake.invocations { - copiedInvocations[key] = value - } - return copiedInvocations -} - -func (fake *FakeCredVarsTracker) 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 _ vars.CredVarsTracker = new(FakeCredVarsTracker) diff --git a/vars/varsfakes/fake_variables.go b/vars/varsfakes/fake_variables.go new file mode 100644 index 000000000..0428a7acd --- /dev/null +++ b/vars/varsfakes/fake_variables.go @@ -0,0 +1,189 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package varsfakes + +import ( + "sync" + + "github.com/concourse/concourse/vars" +) + +type FakeVariables struct { + GetStub func(vars.VariableDefinition) (interface{}, bool, error) + getMutex sync.RWMutex + getArgsForCall []struct { + arg1 vars.VariableDefinition + } + getReturns struct { + result1 interface{} + result2 bool + result3 error + } + getReturnsOnCall map[int]struct { + result1 interface{} + result2 bool + result3 error + } + ListStub func() ([]vars.VariableDefinition, error) + listMutex sync.RWMutex + listArgsForCall []struct { + } + listReturns struct { + result1 []vars.VariableDefinition + result2 error + } + listReturnsOnCall map[int]struct { + result1 []vars.VariableDefinition + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeVariables) Get(arg1 vars.VariableDefinition) (interface{}, bool, error) { + fake.getMutex.Lock() + ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] + fake.getArgsForCall = append(fake.getArgsForCall, struct { + arg1 vars.VariableDefinition + }{arg1}) + fake.recordInvocation("Get", []interface{}{arg1}) + fake.getMutex.Unlock() + if fake.GetStub != nil { + return fake.GetStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + fakeReturns := fake.getReturns + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeVariables) GetCallCount() int { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + return len(fake.getArgsForCall) +} + +func (fake *FakeVariables) GetCalls(stub func(vars.VariableDefinition) (interface{}, bool, error)) { + fake.getMutex.Lock() + defer fake.getMutex.Unlock() + fake.GetStub = stub +} + +func (fake *FakeVariables) GetArgsForCall(i int) vars.VariableDefinition { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + argsForCall := fake.getArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeVariables) GetReturns(result1 interface{}, result2 bool, result3 error) { + fake.getMutex.Lock() + defer fake.getMutex.Unlock() + fake.GetStub = nil + fake.getReturns = struct { + result1 interface{} + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeVariables) GetReturnsOnCall(i int, result1 interface{}, result2 bool, result3 error) { + fake.getMutex.Lock() + defer fake.getMutex.Unlock() + fake.GetStub = nil + if fake.getReturnsOnCall == nil { + fake.getReturnsOnCall = make(map[int]struct { + result1 interface{} + result2 bool + result3 error + }) + } + fake.getReturnsOnCall[i] = struct { + result1 interface{} + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeVariables) List() ([]vars.VariableDefinition, error) { + fake.listMutex.Lock() + ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] + fake.listArgsForCall = append(fake.listArgsForCall, struct { + }{}) + fake.recordInvocation("List", []interface{}{}) + fake.listMutex.Unlock() + if fake.ListStub != nil { + return fake.ListStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.listReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeVariables) ListCallCount() int { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return len(fake.listArgsForCall) +} + +func (fake *FakeVariables) ListCalls(stub func() ([]vars.VariableDefinition, error)) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = stub +} + +func (fake *FakeVariables) ListReturns(result1 []vars.VariableDefinition, result2 error) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = nil + fake.listReturns = struct { + result1 []vars.VariableDefinition + result2 error + }{result1, result2} +} + +func (fake *FakeVariables) ListReturnsOnCall(i int, result1 []vars.VariableDefinition, result2 error) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = nil + if fake.listReturnsOnCall == nil { + fake.listReturnsOnCall = make(map[int]struct { + result1 []vars.VariableDefinition + result2 error + }) + } + fake.listReturnsOnCall[i] = struct { + result1 []vars.VariableDefinition + result2 error + }{result1, result2} +} + +func (fake *FakeVariables) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeVariables) 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 _ vars.Variables = new(FakeVariables)