factory.go

Documentation: sigs.k8s.io/kustomize/api/resmap

     1  // Copyright 2019 The Kubernetes Authors.
     2  // SPDX-License-Identifier: Apache-2.0
     3  
     4  package resmap
     5  
     6  import (
     7  	"sigs.k8s.io/kustomize/api/ifc"
     8  	"sigs.k8s.io/kustomize/api/internal/kusterr"
     9  	"sigs.k8s.io/kustomize/api/resource"
    10  	"sigs.k8s.io/kustomize/api/types"
    11  	"sigs.k8s.io/kustomize/kyaml/errors"
    12  	"sigs.k8s.io/kustomize/kyaml/yaml"
    13  )
    14  
    15  // Factory makes instances of ResMap.
    16  type Factory struct {
    17  	// Makes resources.
    18  	resF *resource.Factory
    19  }
    20  
    21  // NewFactory returns a new resmap.Factory.
    22  func NewFactory(rf *resource.Factory) *Factory {
    23  	return &Factory{resF: rf}
    24  }
    25  
    26  // RF returns a resource.Factory.
    27  func (rmF *Factory) RF() *resource.Factory {
    28  	return rmF.resF
    29  }
    30  
    31  func New() ResMap {
    32  	return newOne()
    33  }
    34  
    35  // FromResource returns a ResMap with one entry.
    36  func (rmF *Factory) FromResource(res *resource.Resource) ResMap {
    37  	m, err := newResMapFromResourceSlice([]*resource.Resource{res})
    38  	if err != nil {
    39  		panic(err)
    40  	}
    41  	return m
    42  }
    43  
    44  // FromResourceSlice returns a ResMap with a slice of resources.
    45  func (rmF *Factory) FromResourceSlice(ress []*resource.Resource) ResMap {
    46  	m, err := newResMapFromResourceSlice(ress)
    47  	if err != nil {
    48  		panic(err)
    49  	}
    50  	return m
    51  }
    52  
    53  // FromFile returns a ResMap given a resource path.
    54  func (rmF *Factory) FromFile(
    55  	loader ifc.Loader, path string) (ResMap, error) {
    56  	content, err := loader.Load(path)
    57  	if err != nil {
    58  		return nil, err
    59  	}
    60  	m, err := rmF.NewResMapFromBytes(content)
    61  	if err != nil {
    62  		return nil, kusterr.Handler(err, path)
    63  	}
    64  	return m, nil
    65  }
    66  
    67  // NewResMapFromBytes decodes a list of objects in byte array format.
    68  func (rmF *Factory) NewResMapFromBytes(b []byte) (ResMap, error) {
    69  	resources, err := rmF.resF.SliceFromBytes(b)
    70  	if err != nil {
    71  		return nil, err
    72  	}
    73  	return newResMapFromResourceSlice(resources)
    74  }
    75  
    76  // NewResMapFromConfigMapArgs returns a Resource slice given
    77  // a configmap metadata slice from kustomization file.
    78  func (rmF *Factory) NewResMapFromConfigMapArgs(
    79  	kvLdr ifc.KvLoader, argList []types.ConfigMapArgs) (ResMap, error) {
    80  	var resources []*resource.Resource
    81  	for i := range argList {
    82  		res, err := rmF.resF.MakeConfigMap(kvLdr, &argList[i])
    83  		if err != nil {
    84  			return nil, errors.WrapPrefixf(err, "NewResMapFromConfigMapArgs")
    85  		}
    86  		resources = append(resources, res)
    87  	}
    88  	return newResMapFromResourceSlice(resources)
    89  }
    90  
    91  // FromConfigMapArgs creates a new ResMap containing one ConfigMap.
    92  func (rmF *Factory) FromConfigMapArgs(
    93  	kvLdr ifc.KvLoader, args types.ConfigMapArgs) (ResMap, error) {
    94  	res, err := rmF.resF.MakeConfigMap(kvLdr, &args)
    95  	if err != nil {
    96  		return nil, err
    97  	}
    98  	return rmF.FromResource(res), nil
    99  }
   100  
   101  // NewResMapFromSecretArgs takes a SecretArgs slice, generates
   102  // secrets from each entry, and accumulates them in a ResMap.
   103  func (rmF *Factory) NewResMapFromSecretArgs(
   104  	kvLdr ifc.KvLoader, argsList []types.SecretArgs) (ResMap, error) {
   105  	var resources []*resource.Resource
   106  	for i := range argsList {
   107  		res, err := rmF.resF.MakeSecret(kvLdr, &argsList[i])
   108  		if err != nil {
   109  			return nil, errors.WrapPrefixf(err, "NewResMapFromSecretArgs")
   110  		}
   111  		resources = append(resources, res)
   112  	}
   113  	return newResMapFromResourceSlice(resources)
   114  }
   115  
   116  // FromSecretArgs creates a new ResMap containing one secret.
   117  func (rmF *Factory) FromSecretArgs(
   118  	kvLdr ifc.KvLoader, args types.SecretArgs) (ResMap, error) {
   119  	res, err := rmF.resF.MakeSecret(kvLdr, &args)
   120  	if err != nil {
   121  		return nil, err
   122  	}
   123  	return rmF.FromResource(res), nil
   124  }
   125  
   126  func newResMapFromResourceSlice(
   127  	resources []*resource.Resource) (ResMap, error) {
   128  	result := New()
   129  	for _, res := range resources {
   130  		err := result.Append(res)
   131  		if err != nil {
   132  			return nil, err
   133  		}
   134  	}
   135  	return result, nil
   136  }
   137  
   138  // NewResMapFromRNodeSlice returns a ResMap from a slice of RNodes
   139  func (rmF *Factory) NewResMapFromRNodeSlice(s []*yaml.RNode) (ResMap, error) {
   140  	rs, err := rmF.resF.ResourcesFromRNodes(s)
   141  	if err != nil {
   142  		return nil, err
   143  	}
   144  	return newResMapFromResourceSlice(rs)
   145  }
   146
View as plain text