kubernetes-sigs/kustomize
1
0
Fork 0
mirror of https://github.com/kubernetes-sigs/kustomize.git synced 2026-07-17 17:52:12 +00:00
Code Issues Packages Projects Releases 1 Wiki Activity

Delete v1 setters code

Browse Source
This commit is contained in:
Phani Teja Marupaka
2020-11-12 15:29:07 -08:00
parent eddd872eca
commit 2278e01b7f
12 changed files with 100 additions and 852 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
kyaml/openapi/openapi.go
View File

@@ -359,7 +359,7 @@ func (rs *ResourceSchema) PatchStrategyAndKeyList() (string, []string) {
mkList, found := rs.Schema.Extensions[kubernetesMergeKeyMapList]
if found {
//mkList is []interface, convert to []string
// mkList is []interface, convert to []string
mkListStr := make([]string, len(mkList.([]interface{})))
for i, v := range mkList.([]interface{}) {

39
kyaml/setters/addkio.go
View File

@@ -1,39 +0,0 @@
// Copyright 2019 The Kubernetes Authors.
// SPDX-License-Identifier: Apache-2.0
package setters
import (
"sigs.k8s.io/kustomize/kyaml/kio"
"sigs.k8s.io/kustomize/kyaml/yaml"
)
var _ kio.Filter = &CreateSetter{}
// CreateSetter creates a custom setter as an OpenAPI property through a comment
type CreateSetter struct {
// customFieldSetter is the marker to set
SetPartialField customFieldSetter
// ResourceMeta defines the Resource to set the marker on
ResourceMeta yaml.ResourceMeta
}
func (s *CreateSetter) Filter(input []*yaml.RNode) ([]*yaml.RNode, error) {
for i := range input {
m, err := input[i].GetMeta()
if err != nil {
return nil, err
}
if s.ResourceMeta.Name != "" && m.Name != s.ResourceMeta.Name {
continue
}
if s.ResourceMeta.Kind != "" && m.Kind != s.ResourceMeta.Kind {
continue
}
if err := input[i].PipeE(&s.SetPartialField); err != nil {
return nil, err
}
}
return input, nil
}

118
kyaml/setters/addyaml.go
View File

@@ -1,118 +0,0 @@
// Copyright 2019 The Kubernetes Authors.
// SPDX-License-Identifier: Apache-2.0
package setters
import (
"strings"
"sigs.k8s.io/kustomize/kyaml/errors"
"sigs.k8s.io/kustomize/kyaml/fieldmeta"
"sigs.k8s.io/kustomize/kyaml/yaml"
)
var _ yaml.Filter = &customFieldSetter{}
// customFieldSetter creates a new custom field setter
type customFieldSetter struct {
// Path is the path of the field to add the setter for
Field string
// Setter is the setter to add
Setter fieldmeta.PartialFieldSetter
// Description is the description to add to the OpenAPI
Description string
// SetBy is the setBy to add to the OpenAPI extension
SetBy string
Type string
// Partial will create a partial setter if set to true
Partial bool
// currentFieldName is the name of the current field being processed
currentFieldName string
}
// Filter performs the setter for a single object
func (m *customFieldSetter) Filter(object *yaml.RNode) (*yaml.RNode, error) {
switch object.YNode().Kind {
case yaml.DocumentNode:
return m.Filter(yaml.NewRNode(object.YNode().Content[0]))
case yaml.MappingNode:
return object, object.VisitFields(func(node *yaml.MapNode) error {
// record the current field name, resetting it back to its original value
// when done
n := m.currentFieldName
defer func() { m.currentFieldName = n }()
m.currentFieldName = node.Key.YNode().Value
return node.Value.PipeE(m)
})
case yaml.SequenceNode:
return object, object.VisitElements(func(node *yaml.RNode) error {
return node.PipeE(m)
})
case yaml.ScalarNode:
// if filed is empty, create the setter for all fields with given value
// else only create the setter for given field and value combination, with given name
if m.Field != "" && m.currentFieldName != m.Field {
return object, nil
}
if err := m.create(object); err != nil {
return nil, err
}
return object, nil
default:
return object, nil
}
}
func (m *customFieldSetter) create(field *yaml.RNode) error {
fm := fieldmeta.FieldMeta{}
if err := fm.Read(field); err != nil {
return errors.Wrap(err)
}
if m.Description != "" {
fm.Schema.Description = m.Description
}
fm.Extensions.SetBy = m.SetBy
fm.Schema.Type = []string{m.Type}
if !m.Partial {
// doesn't match the supplied value
if field.YNode().Value != m.Setter.Value {
return nil
}
// full setter
fm.Extensions.FieldSetter = &m.Setter
fm.Extensions.PartialFieldSetters = nil
} else {
// doesn't match the supplied value
if !strings.Contains(field.YNode().Value, m.Setter.Value) {
return nil
}
found := false
for i := range fm.Extensions.PartialFieldSetters {
s := fm.Extensions.PartialFieldSetters[i]
if s.Name == m.Setter.Name {
// update the setter if we find it
found = true
fm.Extensions.PartialFieldSetters[i] = m.Setter
break
}
}
if !found {
// add the setter if it wasn't found
fm.Extensions.PartialFieldSetters = append(fm.Extensions.PartialFieldSetters, m.Setter)
}
}
if err := fm.Write(field); err != nil {
return errors.Wrap(err)
}
return nil
}

45
kyaml/setters/dokio.go
View File

@@ -1,45 +0,0 @@
// Copyright 2019 The Kubernetes Authors.
// SPDX-License-Identifier: Apache-2.0
package setters
import (
"sigs.k8s.io/kustomize/kyaml/kio"
"sigs.k8s.io/kustomize/kyaml/yaml"
)
var _ kio.Filter = &PerformSetters{}
// PerformSetters sets field values
type PerformSetters struct {
// Name is the name of the setter to perform
Name string
// Value is the value to set
Value string
// Description, if set will annotate the field with a description.
Description string
// SetBy, if set will annotate the field with who set it.
SetBy string
// Count is set by Filter and is the number of fields modified.
Count int
}
func (s *PerformSetters) Filter(input []*yaml.RNode) ([]*yaml.RNode, error) {
for i := range input {
p := &fieldSetter{
Name: s.Name,
Value: s.Value,
Description: s.Description,
SetBy: s.SetBy,
}
if err := input[i].PipeE(p); err != nil {
return nil, err
}
s.Count += p.Count
}
return input, nil
}

130
kyaml/setters/doyaml.go
View File

@@ -1,130 +0,0 @@
// Copyright 2019 The Kubernetes Authors.
// SPDX-License-Identifier: Apache-2.0
// Package sub substitutes strings in fields
package setters
import (
"strings"
"sigs.k8s.io/kustomize/kyaml/fieldmeta"
"sigs.k8s.io/kustomize/kyaml/yaml"
)
var _ yaml.Filter = &fieldSetter{}
// fieldSetter sets part or all of a field value.
type fieldSetter struct {
// Name is the name of the setter to perform.
Name string
// Value is the value to set.
Value string
// Description, if specified will set 'description' for the field. Optional.
Description string
// SetBy, if specified will set 'setBy' for the field. Optional.
SetBy string
// Count is incremented by Filter for each field that is set.
Count int
}
// Filter implements yaml.Filter
func (fs *fieldSetter) Filter(object *yaml.RNode) (*yaml.RNode, error) {
switch object.YNode().Kind {
case yaml.DocumentNode:
// Document is the root of the object and always contains 1 node
return fs.Filter(yaml.NewRNode(object.YNode().Content[0]))
case yaml.MappingNode:
return object, object.VisitFields(func(node *yaml.MapNode) error {
// Traverse each field value
return node.Value.PipeE(fs)
})
case yaml.SequenceNode:
return object, object.VisitElements(func(node *yaml.RNode) error {
// Traverse each list element
return node.PipeE(fs)
})
case yaml.ScalarNode:
// Check if there is a setter matching the name
s, f, partial, err := fs.findSetter(object)
if err != nil {
return nil, err
}
if s == nil {
// no matching setter
return object, nil
}
// set the field value
return object, fs.set(object, s, f, partial)
default:
return object, nil
}
}
// findPartialSetter finds the setter matching the name if one exists
func (fs *fieldSetter) findSetter(field *yaml.RNode) (
*fieldmeta.PartialFieldSetter, *fieldmeta.FieldMeta, bool, error) {
// check if there are any substitutions for this field
var fm = &fieldmeta.FieldMeta{}
if err := fm.Read(field); err != nil {
return nil, nil, false, err
}
if fs.SetBy != "" {
fm.Extensions.SetBy = fs.SetBy
}
if fs.Description != "" {
fm.Schema.Description = fs.Description
}
if fm.Extensions.FieldSetter != nil && fm.Extensions.FieldSetter.Name == fs.Name {
return fm.Extensions.FieldSetter, fm, false, nil
}
// check if there is a matching substitution
for i := range fm.Extensions.PartialFieldSetters {
if fm.Extensions.PartialFieldSetters[i].Name == fs.Name {
return &fm.Extensions.PartialFieldSetters[i], fm, true, nil
}
}
return nil, nil, false, nil
}
// set performs the substitution for the given field, substitution, and metadata
func (fs *fieldSetter) set(
field *yaml.RNode, s *fieldmeta.PartialFieldSetter,
f *fieldmeta.FieldMeta, partial bool) error {
if s.Value == fs.Value || !strings.Contains(field.YNode().Value, s.Value) {
// no substitutions necessary -- already substituted or doesn't have the set value
// which acts as a marker
return nil
}
// record that the config has been modified
fs.Count++
if !partial {
// full setter
field.YNode().Value = fs.Value
} else {
// replace the current value with the new value
field.YNode().Value = strings.ReplaceAll(field.YNode().Value, s.Value, fs.Value)
}
// be sure to set the tag to the matching type so the yaml doesn't incorrectly quote
// integers or booleans as strings
fType := fieldmeta.FieldValueType(f.Schema.Type[0])
if err := fType.Validate(field.YNode().Value); err != nil {
return err
}
field.YNode().Tag = fType.Tag()
// update the comment on the field
s.Value = fs.Value
if err := f.Write(field); err != nil {
return err
}
return nil
}

65
kyaml/setters/lookupkio.go
View File

@@ -1,65 +0,0 @@
// Copyright 2019 The Kubernetes Authors.
// SPDX-License-Identifier: Apache-2.0
package setters
import (
"sort"
"sigs.k8s.io/kustomize/kyaml/kio"
"sigs.k8s.io/kustomize/kyaml/yaml"
)
var _ kio.Filter = &LookupSetters{}
// LookupSetters identifies setters for a collection of Resources
type LookupSetters struct {
// Name is the name of the setter to match. Optional.
Name string
// SetterCounts is populated by Filter and contains the count of fields matching each setter.
SetterCounts []setterCount
}
// setterCount records the identified setters and number of fields matching those setters
type setterCount struct {
// Count is the number of substitutions possible to perform
Count int
// setter is the substitution found
setter
}
// Filter implements kio.Filter
func (l *LookupSetters) Filter(input []*yaml.RNode) ([]*yaml.RNode, error) {
setters := map[string]*setterCount{}
for i := range input {
// lookup substitutions for this object
ls := &lookupSetters{Name: l.Name}
if err := input[i].PipeE(ls); err != nil {
return nil, err
}
// aggregate counts for each setter by name. takes the description and value from
// the first setter for each name encountered.
for j := range ls.Setters {
setter := ls.Setters[j]
curr, found := setters[setter.Name]
if !found {
curr = &setterCount{setter: setter}
setters[setter.Name] = curr
}
curr.Count++
}
}
// pull out and sort the results by setter name
for _, v := range setters {
l.SetterCounts = append(l.SetterCounts, *v)
}
sort.Slice(l.SetterCounts, func(i, j int) bool {
return l.SetterCounts[i].Name < l.SetterCounts[j].Name
})
return input, nil
}

86
kyaml/setters/lookupyaml.go
View File

@@ -1,86 +0,0 @@
// Copyright 2019 The Kubernetes Authors.
// SPDX-License-Identifier: Apache-2.0
package setters
import (
"sigs.k8s.io/kustomize/kyaml/fieldmeta"
"sigs.k8s.io/kustomize/kyaml/yaml"
)
var _ yaml.Filter = &lookupSetters{}
// lookupSetters looks up setters for a Resource
type lookupSetters struct {
// Name of the setter to lookup. Optional
Name string
// Setters is a list of setters that were found
Setters []setter
}
type setter struct {
fieldmeta.PartialFieldSetter
Description string
Type string
SetBy string
}
func (ls *lookupSetters) Filter(object *yaml.RNode) (*yaml.RNode, error) {
switch object.YNode().Kind {
case yaml.DocumentNode:
// skip the document node
return ls.Filter(yaml.NewRNode(object.YNode().Content[0]))
case yaml.MappingNode:
return object, object.VisitFields(func(node *yaml.MapNode) error {
return node.Value.PipeE(ls)
})
case yaml.SequenceNode:
return object, object.VisitElements(func(node *yaml.RNode) error {
return node.PipeE(ls)
})
case yaml.ScalarNode:
return object, ls.lookup(object)
default:
return object, nil
}
}
// lookup finds any setters for a field
func (ls *lookupSetters) lookup(field *yaml.RNode) error {
// check if there is a substitution for this field
var fm = &fieldmeta.FieldMeta{}
if err := fm.Read(field); err != nil {
return err
}
if fm.Extensions.FieldSetter != nil {
if ls.Name != "" && ls.Name != fm.Extensions.FieldSetter.Name {
// skip this setter, it doesn't match the specified setter
return nil
}
// full setter
ls.Setters = append(ls.Setters, setter{
PartialFieldSetter: *fm.Extensions.FieldSetter,
Description: fm.Schema.Description,
Type: fm.Schema.Type[0],
SetBy: fm.Extensions.SetBy,
})
return nil
}
// partial setters
for i := range fm.Extensions.PartialFieldSetters {
if ls.Name != "" && ls.Name != fm.Extensions.PartialFieldSetters[i].Name {
// skip this setter
continue
}
ls.Setters = append(ls.Setters, setter{
PartialFieldSetter: fm.Extensions.PartialFieldSetters[i],
Description: fm.Schema.Description,
Type: fm.Schema.Type[0],
SetBy: fm.Extensions.SetBy,
})
}
return nil
}