mirror of
https://github.com/GoogleContainerTools/kaniko
synced 2026-09-30 19:23:45 +02:00
Damien Degois
1bf529e6d9
* Add flag to remap registries for any registry mirror The purpose of this PR is to add an option to remap registries, a kind of generalized `--registry-mirror`. This is helpful for air-gapped environments and/or when local registry mirrors are available (not limited to docker.io). This allows user to reference any images without having to change their location. It also permit to separate infra related configuration (the mirrors) from CI/CD pipeline definition by using an environment variable for example (the reason behind the early return if flag provided but empty). Therefore you can have a pipeline calling kaniko with `--registry-map=$REGISTRY_MAP` and have the `REGISTRY_MAP` populated via the runner's env by another team, and the absence of env wouldn't trigger a failure, it makes the pipeline env independent. I've also considered the option of environment variables directly but it doesn't seems to be in kaniko's philosophy. This makes quite some duplicated code :/ One option to keep the mirror flag and behavior would be to use only one codebase and convert `--registry-mirror=VALUE` to `--registry-map=index.docker.io=VALUE` internally. Suggestions welcome! * Configure logging config sooner to be able to use it in flag parsing * Replace registry mirrors by maps logic and use env var * Add env vars to README.md * Fix test
128 lines
3.0 KiB
Go
128 lines
3.0 KiB
Go
/*
|
|
Copyright 2018 Google LLC
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// This type is used to supported passing in multiple flags
|
|
type multiArg []string
|
|
|
|
// Now, for our new type, implement the two methods of
|
|
// the flag.Value interface...
|
|
// The first method is String() string
|
|
func (b *multiArg) String() string {
|
|
return strings.Join(*b, ",")
|
|
}
|
|
|
|
// The second method is Set(value string) error
|
|
func (b *multiArg) Set(value string) error {
|
|
logrus.Debugf("Appending to multi args %s", value)
|
|
*b = append(*b, value)
|
|
return nil
|
|
}
|
|
|
|
// The third is Type() string
|
|
func (b *multiArg) Type() string {
|
|
return "multi-arg type"
|
|
}
|
|
|
|
func (b *multiArg) Contains(v string) bool {
|
|
for _, s := range *b {
|
|
if s == v {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// This type is used to supported passing in multiple key=value flags
|
|
type keyValueArg map[string]string
|
|
|
|
// Now, for our new type, implement the two methods of
|
|
// the flag.Value interface...
|
|
// The first method is String() string
|
|
func (a *keyValueArg) String() string {
|
|
var result []string
|
|
for key := range *a {
|
|
result = append(result, fmt.Sprintf("%s=%s", key, (*a)[key]))
|
|
}
|
|
return strings.Join(result, ",")
|
|
}
|
|
|
|
// The second method is Set(value string) error
|
|
func (a *keyValueArg) Set(value string) error {
|
|
valueSplit := strings.SplitN(value, "=", 2)
|
|
if len(valueSplit) < 2 {
|
|
return fmt.Errorf("invalid argument value. expect key=value, got %s", value)
|
|
}
|
|
(*a)[valueSplit[0]] = valueSplit[1]
|
|
return nil
|
|
}
|
|
|
|
// The third is Type() string
|
|
func (a *keyValueArg) Type() string {
|
|
return "key-value-arg type"
|
|
}
|
|
|
|
type multiKeyMultiValueArg map[string][]string
|
|
|
|
func (c *multiKeyMultiValueArg) parseKV(value string) error {
|
|
valueSplit := strings.SplitN(value, "=", 2)
|
|
if len(valueSplit) < 2 {
|
|
return fmt.Errorf("invalid argument value. expect key=value, got %s", value)
|
|
}
|
|
(*c)[valueSplit[0]] = append((*c)[valueSplit[0]], valueSplit[1])
|
|
return nil
|
|
}
|
|
|
|
func (c *multiKeyMultiValueArg) String() string {
|
|
var result []string
|
|
for key := range *c {
|
|
for _, val := range (*c)[key] {
|
|
result = append(result, fmt.Sprintf("%s=%s", key, val))
|
|
}
|
|
}
|
|
return strings.Join(result, ";")
|
|
|
|
}
|
|
|
|
func (c *multiKeyMultiValueArg) Set(value string) error {
|
|
if value == "" {
|
|
return nil
|
|
}
|
|
if strings.Contains(value, ";") {
|
|
kvpairs := strings.Split(value, ";")
|
|
for _, kv := range kvpairs {
|
|
err := c.parseKV(kv)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
return c.parseKV(value)
|
|
}
|
|
|
|
func (c *multiKeyMultiValueArg) Type() string {
|
|
return "key-multi-value-arg type"
|
|
}
|