gitlab.azmi.pl/azmi-open-source/helm@v3.0.0-beta.3+incompatible/pkg/chart/loader/load.go (about) 1 /* 2 Copyright The Helm Authors. 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 package loader 18 19 import ( 20 "bytes" 21 "log" 22 "os" 23 "path/filepath" 24 "strings" 25 26 "github.com/pkg/errors" 27 "sigs.k8s.io/yaml" 28 29 "helm.sh/helm/pkg/chart" 30 ) 31 32 // ChartLoader loads a chart. 33 type ChartLoader interface { 34 Load() (*chart.Chart, error) 35 } 36 37 // Loader returns a new ChartLoader appropriate for the given chart name 38 func Loader(name string) (ChartLoader, error) { 39 fi, err := os.Stat(name) 40 if err != nil { 41 return nil, err 42 } 43 if fi.IsDir() { 44 return DirLoader(name), nil 45 } 46 return FileLoader(name), nil 47 48 } 49 50 // Load takes a string name, tries to resolve it to a file or directory, and then loads it. 51 // 52 // This is the preferred way to load a chart. It will discover the chart encoding 53 // and hand off to the appropriate chart reader. 54 // 55 // If a .helmignore file is present, the directory loader will skip loading any files 56 // matching it. But .helmignore is not evaluated when reading out of an archive. 57 func Load(name string) (*chart.Chart, error) { 58 l, err := Loader(name) 59 if err != nil { 60 return nil, err 61 } 62 return l.Load() 63 } 64 65 // BufferedFile represents an archive file buffered for later processing. 66 type BufferedFile struct { 67 Name string 68 Data []byte 69 } 70 71 // LoadFiles loads from in-memory files. 72 func LoadFiles(files []*BufferedFile) (*chart.Chart, error) { 73 c := new(chart.Chart) 74 subcharts := make(map[string][]*BufferedFile) 75 76 for _, f := range files { 77 switch { 78 case f.Name == "Chart.yaml": 79 if c.Metadata == nil { 80 c.Metadata = new(chart.Metadata) 81 } 82 if err := yaml.Unmarshal(f.Data, c.Metadata); err != nil { 83 return c, errors.Wrap(err, "cannot load Chart.yaml") 84 } 85 // NOTE(bacongobbler): while the chart specification says that APIVersion must be set, 86 // Helm 2 accepted charts that did not provide an APIVersion in their chart metadata. 87 // Because of that, if APIVersion is unset, we should assume we're loading a v1 chart. 88 if c.Metadata.APIVersion == "" { 89 c.Metadata.APIVersion = chart.APIVersionV1 90 } 91 case f.Name == "Chart.lock": 92 c.Lock = new(chart.Lock) 93 if err := yaml.Unmarshal(f.Data, &c.Lock); err != nil { 94 return c, errors.Wrap(err, "cannot load Chart.lock") 95 } 96 case f.Name == "values.yaml": 97 c.Values = make(map[string]interface{}) 98 if err := yaml.Unmarshal(f.Data, &c.Values); err != nil { 99 return c, errors.Wrap(err, "cannot load values.yaml") 100 } 101 case f.Name == "values.schema.json": 102 c.Schema = f.Data 103 104 // Deprecated: requirements.yaml is deprecated use Chart.yaml. 105 // We will handle it for you because we are nice people 106 case f.Name == "requirements.yaml": 107 if c.Metadata.APIVersion != chart.APIVersionV1 { 108 log.Printf("Warning: Dependencies are handled in Chart.yaml since apiVersion \"v2\". We recommend migrating dependencies to Chart.yaml.") 109 } 110 if c.Metadata == nil { 111 c.Metadata = new(chart.Metadata) 112 } 113 if err := yaml.Unmarshal(f.Data, c.Metadata); err != nil { 114 return c, errors.Wrap(err, "cannot load requirements.yaml") 115 } 116 // Deprecated: requirements.lock is deprecated use Chart.lock. 117 case f.Name == "requirements.lock": 118 c.Lock = new(chart.Lock) 119 if err := yaml.Unmarshal(f.Data, &c.Lock); err != nil { 120 return c, errors.Wrap(err, "cannot load requirements.lock") 121 } 122 123 case strings.HasPrefix(f.Name, "templates/"): 124 c.Templates = append(c.Templates, &chart.File{Name: f.Name, Data: f.Data}) 125 case strings.HasPrefix(f.Name, "charts/"): 126 if filepath.Ext(f.Name) == ".prov" { 127 c.Files = append(c.Files, &chart.File{Name: f.Name, Data: f.Data}) 128 continue 129 } 130 131 fname := strings.TrimPrefix(f.Name, "charts/") 132 cname := strings.SplitN(fname, "/", 2)[0] 133 subcharts[cname] = append(subcharts[cname], &BufferedFile{Name: fname, Data: f.Data}) 134 default: 135 c.Files = append(c.Files, &chart.File{Name: f.Name, Data: f.Data}) 136 } 137 } 138 139 if err := c.Validate(); err != nil { 140 return c, err 141 } 142 143 for n, files := range subcharts { 144 var sc *chart.Chart 145 var err error 146 switch { 147 case strings.IndexAny(n, "_.") == 0: 148 continue 149 case filepath.Ext(n) == ".tgz": 150 file := files[0] 151 if file.Name != n { 152 return c, errors.Errorf("error unpacking tar in %s: expected %s, got %s", c.Name(), n, file.Name) 153 } 154 // Untar the chart and add to c.Dependencies 155 sc, err = LoadArchive(bytes.NewBuffer(file.Data)) 156 default: 157 // We have to trim the prefix off of every file, and ignore any file 158 // that is in charts/, but isn't actually a chart. 159 buff := make([]*BufferedFile, 0, len(files)) 160 for _, f := range files { 161 parts := strings.SplitN(f.Name, "/", 2) 162 if len(parts) < 2 { 163 continue 164 } 165 f.Name = parts[1] 166 buff = append(buff, f) 167 } 168 sc, err = LoadFiles(buff) 169 } 170 171 if err != nil { 172 return c, errors.Wrapf(err, "error unpacking %s in %s", n, c.Name()) 173 } 174 c.AddDependency(sc) 175 } 176 177 return c, nil 178 }