github/kubernetes
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update generated

Browse Source
This commit is contained in:
jennybuckley
2019-07-17 14:59:50 -07:00
committed by Jennifer Buckley
parent 229894c730
commit 018a3db25e
11 changed files with 90 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
vendor/sigs.k8s.io/structured-merge-diff/fieldpath/managers.go generated vendored
View File

@@ -16,16 +16,42 @@ package fieldpath
// APIVersion describes the version of an object or of a fieldset.
type APIVersion string
type VersionedSet interface {
Set() *Set
APIVersion() APIVersion
Applied() bool
}
// VersionedSet associates a version to a set.
type VersionedSet struct {
*Set
APIVersion APIVersion
Applied bool
type versionedSet struct {
set *Set
apiVersion APIVersion
applied bool
}
func NewVersionedSet(set *Set, apiVersion APIVersion, applied bool) VersionedSet {
return versionedSet{
set: set,
apiVersion: apiVersion,
applied: applied,
}
}
func (v versionedSet) Set() *Set {
return v.set
}
func (v versionedSet) APIVersion() APIVersion {
return v.apiVersion
}
func (v versionedSet) Applied() bool {
return v.applied
}
// ManagedFields is a map from manager to VersionedSet (what they own in
// what version).
type ManagedFields map[string]*VersionedSet
type ManagedFields map[string]VersionedSet
// Difference returns a symmetric difference between two Managers. If a
// given user's entry has version X in lhs and version Y in rhs, then
@@ -37,7 +63,7 @@ func (lhs ManagedFields) Difference(rhs ManagedFields) ManagedFields {
for manager, left := range lhs {
right, ok := rhs[manager]
if !ok {
if !left.Empty() {
if !left.Set().Empty() {
diff[manager] = left
}
continue
@@ -46,17 +72,14 @@ func (lhs ManagedFields) Difference(rhs ManagedFields) ManagedFields {
// If we have sets in both but their version
// differs, we don't even diff and keep the
// entire thing.
if left.APIVersion != right.APIVersion {
if left.APIVersion() != right.APIVersion() {
diff[manager] = right
continue
}
newSet := left.Difference(right.Set).Union(right.Difference(left.Set))
newSet := left.Set().Difference(right.Set()).Union(right.Set().Difference(left.Set()))
if !newSet.Empty() {
diff[manager] = &VersionedSet{
Set: newSet,
APIVersion: right.APIVersion,
}
diff[manager] = NewVersionedSet(newSet, right.APIVersion(), false)
}
}
@@ -65,7 +88,7 @@ func (lhs ManagedFields) Difference(rhs ManagedFields) ManagedFields {
// Already done
continue
}
if !set.Empty() {
if !set.Set().Empty() {
diff[manager] = set
}
}

2
vendor/sigs.k8s.io/structured-merge-diff/merge/conflict.go generated vendored
View File

@@ -79,7 +79,7 @@ func ConflictsFromManagers(sets fieldpath.ManagedFields) Conflicts {
conflicts := []Conflict{}
for manager, set := range sets {
set.Iterate(func(p fieldpath.Path) {
set.Set().Iterate(func(p fieldpath.Path) {
conflicts = append(conflicts, Conflict{
Manager: manager,
Path: p,

91
vendor/sigs.k8s.io/structured-merge-diff/merge/update.go generated vendored
View File

@@ -36,25 +36,23 @@ type Updater struct {
func (s *Updater) update(oldObject, newObject *typed.TypedValue, version fieldpath.APIVersion, managers fieldpath.ManagedFields, workflow string, force bool) (fieldpath.ManagedFields, error) {
conflicts := fieldpath.ManagedFields{}
removed := fieldpath.ManagedFields{}
type Versioned struct {
oldObject *typed.TypedValue
newObject *typed.TypedValue
compare, err := oldObject.Compare(newObject)
if err != nil {
return nil, fmt.Errorf("failed to compare objects: %v", err)
}
versions := map[fieldpath.APIVersion]Versioned{
version: {
oldObject: oldObject,
newObject: newObject,
},
versions := map[fieldpath.APIVersion]*typed.Comparison{
version: compare,
}
for manager, managerSet := range managers {
if manager == workflow {
continue
}
versioned, ok := versions[managerSet.APIVersion]
compare, ok := versions[managerSet.APIVersion()]
if !ok {
var err error
versioned.oldObject, err = s.Converter.Convert(oldObject, managerSet.APIVersion)
versionedOldObject, err := s.Converter.Convert(oldObject, managerSet.APIVersion())
if err != nil {
if s.Converter.IsMissingVersionError(err) {
delete(managers, manager)
@@ -62,7 +60,7 @@ func (s *Updater) update(oldObject, newObject *typed.TypedValue, version fieldpa
}
return nil, fmt.Errorf("failed to convert old object: %v", err)
}
versioned.newObject, err = s.Converter.Convert(newObject, managerSet.APIVersion)
versionedNewObject, err := s.Converter.Convert(newObject, managerSet.APIVersion())
if err != nil {
if s.Converter.IsMissingVersionError(err) {
delete(managers, manager)
@@ -70,26 +68,20 @@ func (s *Updater) update(oldObject, newObject *typed.TypedValue, version fieldpa
}
return nil, fmt.Errorf("failed to convert new object: %v", err)
}
versions[managerSet.APIVersion] = versioned
}
compare, err := versioned.oldObject.Compare(versioned.newObject)
if err != nil {
return nil, fmt.Errorf("failed to compare objects: %v", err)
compare, err = versionedOldObject.Compare(versionedNewObject)
if err != nil {
return nil, fmt.Errorf("failed to compare objects: %v", err)
}
versions[managerSet.APIVersion()] = compare
}
conflictSet := managerSet.Intersection(compare.Modified.Union(compare.Added))
conflictSet := managerSet.Set().Intersection(compare.Modified.Union(compare.Added))
if !conflictSet.Empty() {
conflicts[manager] = &fieldpath.VersionedSet{
Set: conflictSet,
APIVersion: managerSet.APIVersion,
}
conflicts[manager] = fieldpath.NewVersionedSet(conflictSet, managerSet.APIVersion(), false)
}
if !compare.Removed.Empty() {
removed[manager] = &fieldpath.VersionedSet{
Set: compare.Removed,
APIVersion: managerSet.APIVersion,
}
removed[manager] = fieldpath.NewVersionedSet(compare.Removed, managerSet.APIVersion(), false)
}
}
@@ -98,15 +90,15 @@ func (s *Updater) update(oldObject, newObject *typed.TypedValue, version fieldpa
}
for manager, conflictSet := range conflicts {
managers[manager].Set = managers[manager].Set.Difference(conflictSet.Set)
managers[manager] = fieldpath.NewVersionedSet(managers[manager].Set().Difference(conflictSet.Set()), managers[manager].APIVersion(), managers[manager].Applied())
}
for manager, removedSet := range removed {
managers[manager].Set = managers[manager].Set.Difference(removedSet.Set)
managers[manager] = fieldpath.NewVersionedSet(managers[manager].Set().Difference(removedSet.Set()), managers[manager].APIVersion(), managers[manager].Applied())
}
for manager := range managers {
if managers[manager].Set.Empty() {
if managers[manager].Set().Empty() {
delete(managers, manager)
}
}
@@ -134,13 +126,14 @@ func (s *Updater) Update(liveObject, newObject *typed.TypedValue, version fieldp
return nil, fieldpath.ManagedFields{}, fmt.Errorf("failed to compare live and new objects: %v", err)
}
if _, ok := managers[manager]; !ok {
managers[manager] = &fieldpath.VersionedSet{
Set: fieldpath.NewSet(),
}
managers[manager] = fieldpath.NewVersionedSet(fieldpath.NewSet(), version, false)
}
managers[manager].Set = managers[manager].Set.Union(compare.Modified).Union(compare.Added).Difference(compare.Removed)
managers[manager].APIVersion = version
if managers[manager].Set.Empty() {
managers[manager] = fieldpath.NewVersionedSet(
managers[manager].Set().Union(compare.Modified).Union(compare.Added).Difference(compare.Removed),
version,
false,
)
if managers[manager].Set().Empty() {
delete(managers, manager)
}
return newObject, managers, nil
@@ -168,11 +161,7 @@ func (s *Updater) Apply(liveObject, configObject *typed.TypedValue, version fiel
if err != nil {
return nil, fieldpath.ManagedFields{}, fmt.Errorf("failed to get field set: %v", err)
}
managers[manager] = &fieldpath.VersionedSet{
Set: set,
APIVersion: version,
Applied: true,
}
managers[manager] = fieldpath.NewVersionedSet(set, version, true)
newObject, err = s.prune(newObject, managers, manager, lastSet)
if err != nil {
return nil, fieldpath.ManagedFields{}, fmt.Errorf("failed to prune fields: %v", err)
@@ -196,18 +185,18 @@ func shallowCopyManagers(managers fieldpath.ManagedFields) fieldpath.ManagedFiel
// * applyingManager applied it last time
// * applyingManager didn't apply it this time
// * no other applier claims to manage it
func (s *Updater) prune(merged *typed.TypedValue, managers fieldpath.ManagedFields, applyingManager string, lastSet *fieldpath.VersionedSet) (*typed.TypedValue, error) {
if lastSet == nil || lastSet.Set.Empty() {
func (s *Updater) prune(merged *typed.TypedValue, managers fieldpath.ManagedFields, applyingManager string, lastSet fieldpath.VersionedSet) (*typed.TypedValue, error) {
if lastSet == nil || lastSet.Set().Empty() {
return merged, nil
}
convertedMerged, err := s.Converter.Convert(merged, lastSet.APIVersion)
convertedMerged, err := s.Converter.Convert(merged, lastSet.APIVersion())
if err != nil {
if s.Converter.IsMissingVersionError(err) {
return merged, nil
}
return nil, fmt.Errorf("failed to convert merged object to last applied version: %v", err)
}
pruned := convertedMerged.RemoveItems(lastSet.Set)
pruned := convertedMerged.RemoveItems(lastSet.Set())
pruned, err = s.addBackOwnedItems(convertedMerged, pruned, managers, applyingManager)
if err != nil {
return nil, fmt.Errorf("failed add back owned items: %v", err)
@@ -216,7 +205,7 @@ func (s *Updater) prune(merged *typed.TypedValue, managers fieldpath.ManagedFiel
if err != nil {
return nil, fmt.Errorf("failed add back dangling items: %v", err)
}
return s.Converter.Convert(pruned, managers[applyingManager].APIVersion)
return s.Converter.Convert(pruned, managers[applyingManager].APIVersion())
}
// addBackOwnedItems adds back any list and map items that were removed by prune,
@@ -225,11 +214,11 @@ func (s *Updater) addBackOwnedItems(merged, pruned *typed.TypedValue, managedFie
var err error
managedAtVersion := map[fieldpath.APIVersion]*fieldpath.Set{}
for _, managerSet := range managedFields {
if managerSet.Applied {
if _, ok := managedAtVersion[managerSet.APIVersion]; !ok {
managedAtVersion[managerSet.APIVersion] = fieldpath.NewSet()
if managerSet.Applied() {
if _, ok := managedAtVersion[managerSet.APIVersion()]; !ok {
managedAtVersion[managerSet.APIVersion()] = fieldpath.NewSet()
}
managedAtVersion[managerSet.APIVersion] = managedAtVersion[managerSet.APIVersion].Union(managerSet.Set)
managedAtVersion[managerSet.APIVersion()] = managedAtVersion[managerSet.APIVersion()].Union(managerSet.Set())
}
}
for version, managed := range managedAtVersion {
@@ -263,8 +252,8 @@ func (s *Updater) addBackOwnedItems(merged, pruned *typed.TypedValue, managedFie
// addBackDanglingItems makes sure that the only items removed by prune are items that were
// previously owned by the currently applying manager. This will add back unowned items and items
// which are owned by Updaters that shouldn't be removed.
func (s *Updater) addBackDanglingItems(merged, pruned *typed.TypedValue, lastSet *fieldpath.VersionedSet) (*typed.TypedValue, error) {
convertedPruned, err := s.Converter.Convert(pruned, lastSet.APIVersion)
func (s *Updater) addBackDanglingItems(merged, pruned *typed.TypedValue, lastSet fieldpath.VersionedSet) (*typed.TypedValue, error) {
convertedPruned, err := s.Converter.Convert(pruned, lastSet.APIVersion())
if err != nil {
if s.Converter.IsMissingVersionError(err) {
return merged, nil
@@ -279,5 +268,5 @@ func (s *Updater) addBackDanglingItems(merged, pruned *typed.TypedValue, lastSet
if err != nil {
return nil, fmt.Errorf("failed to create field set from merged object in last applied version: %v", err)
}
return merged.RemoveItems(mergedSet.Difference(prunedSet).Intersection(lastSet.Set)), nil
return merged.RemoveItems(mergedSet.Difference(prunedSet).Intersection(lastSet.Set())), nil
}