+
+
+
+**koanf** is a library for reading configuration from different sources in different formats in Go applications. It is a cleaner, lighter [alternative to spf13/viper](#alternative-to-viper) with better abstractions and extensibility and far fewer dependencies.
+
+koanf v2 has modules (Providers) for reading configuration from a variety of sources such as files, command line flags, environment variables, Vault, and S3 and for parsing (Parsers) formats such as JSON, YAML, TOML, Hashicorp HCL. It is easy to plug in custom parsers and providers.
+
+All external dependencies in providers and parsers are detached from the core and can be installed separately as necessary.
+
+[](https://github.com/knadh/koanf/actions/workflows/test.yml) [](https://pkg.go.dev/github.com/knadh/koanf/v2)
+
+### Installation
+
+```shell
+# Install the core.
+go get -u github.com/knadh/koanf/v2
+
+# Install the necessary Provider(s).
+# Available: file, env, posflag, basicflag, confmap, rawbytes,
+# structs, fs, s3, appconfig/v2, consul/v2, etcd/v2, vault/v2, parameterstore/v2
+# eg: go get -u github.com/knadh/koanf/providers/s3
+# eg: go get -u github.com/knadh/koanf/providers/consul/v2
+
+go get -u github.com/knadh/koanf/providers/file
+
+
+# Install the necessary Parser(s).
+# Available: toml, toml/v2, json, yaml, dotenv, hcl, hjson, nestedtext
+# go get -u github.com/knadh/koanf/parsers/$parser
+
+go get -u github.com/knadh/koanf/parsers/toml
+```
+
+[See the list](#api) of all bundled Providers and Parsers.
+
+### Contents
+
+- [Concepts](#concepts)
+- [Reading config from files](#reading-config-from-files)
+- [Watching file for changes](#watching-file-for-changes)
+- [Reading from command line](#reading-from-command-line)
+- [Reading environment variables](#reading-environment-variables)
+- [Reading raw bytes](#reading-raw-bytes)
+- [Reading from maps and structs](#reading-from-nested-maps)
+- [Unmarshalling and marshalling](#unmarshalling-and-marshalling)
+- [Order of merge and key case sensitivity](#order-of-merge-and-key-case-sensitivity)
+- [Custom Providers and Parsers](#custom-providers-and-parsers)
+- [Custom merge strategies](#custom-merge-strategies)
+- [List of installable Providers and Parsers](#api)
+
+### Concepts
+
+- `koanf.Provider` is a generic interface that provides configuration, for example, from files, environment variables, HTTP sources, or anywhere. The configuration can either be raw bytes that a parser can parse, or it can be a nested `map[string]interface{}` that can be directly loaded.
+- `koanf.Parser` is a generic interface that takes raw bytes, parses, and returns a nested `map[string]interface{}`. For example, JSON and YAML parsers.
+- Once loaded into koanf, configuration are values queried by a delimited key path syntax. eg: `app.server.port`. Any delimiter can be chosen.
+- Configuration from multiple sources can be loaded and merged into a koanf instance, for example, load from a file first and override certain values with flags from the command line.
+
+With these two interface implementations, koanf can obtain configuration in any format from any source, parse it, and make it available to an application.
+
+### Reading config from files
+
+```go
+package main
+
+import (
+ "fmt"
+ "log"
+
+ "github.com/knadh/koanf/v2"
+ "github.com/knadh/koanf/parsers/json"
+ "github.com/knadh/koanf/parsers/yaml"
+ "github.com/knadh/koanf/providers/file"
+)
+
+// Global koanf instance. Use "." as the key path delimiter. This can be "/" or any character.
+var k = koanf.New(".")
+
+func main() {
+ // Load JSON config.
+ if err := k.Load(file.Provider("mock/mock.json"), json.Parser()); err != nil {
+ log.Fatalf("error loading config: %v", err)
+ }
+
+ // Load YAML config and merge into the previously loaded config (because we can).
+ k.Load(file.Provider("mock/mock.yml"), yaml.Parser())
+
+ fmt.Println("parent's name is = ", k.String("parent1.name"))
+ fmt.Println("parent's ID is = ", k.Int("parent1.id"))
+}
+
+```
+
+### Watching file for changes
+Some providers expose a `Watch()` method that makes the provider watch for changes
+in configuration and trigger a callback to reload the configuration.
+This is not goroutine safe if there are concurrent `*Get()` calls happening on the
+koanf object while it is doing a `Load()`. Such scenarios will need mutex locking.
+
+`file, appconfig, vault, consul` providers have a `Watch()` method.
+
+
+```go
+package main
+
+import (
+ "fmt"
+ "log"
+
+ "github.com/knadh/koanf/v2"
+ "github.com/knadh/koanf/parsers/json"
+ "github.com/knadh/koanf/parsers/yaml"
+ "github.com/knadh/koanf/providers/file"
+)
+
+// Global koanf instance. Use "." as the key path delimiter. This can be "/" or any character.
+var k = koanf.New(".")
+
+func main() {
+ // Load JSON config.
+ f := file.Provider("mock/mock.json")
+ if err := k.Load(f, json.Parser()); err != nil {
+ log.Fatalf("error loading config: %v", err)
+ }
+
+ // Load YAML config and merge into the previously loaded config (because we can).
+ k.Load(file.Provider("mock/mock.yml"), yaml.Parser())
+
+ fmt.Println("parent's name is = ", k.String("parent1.name"))
+ fmt.Println("parent's ID is = ", k.Int("parent1.id"))
+
+ // Watch the file and get a callback on change. The callback can do whatever,
+ // like re-load the configuration.
+ // File provider always returns a nil `event`.
+ f.Watch(func(event interface{}, err error) {
+ if err != nil {
+ log.Printf("watch error: %v", err)
+ return
+ }
+
+ // Throw away the old config and load a fresh copy.
+ log.Println("config changed. Reloading ...")
+ k = koanf.New(".")
+ k.Load(f, json.Parser())
+ k.Print()
+ })
+
+ // To stop a file watcher, call:
+ // f.Unwatch()
+
+ // Block forever (and manually make a change to mock/mock.json) to
+ // reload the config.
+ log.Println("waiting forever. Try making a change to mock/mock.json to live reload")
+ <-make(chan bool)
+}
+```
+
+
+### Reading from command line
+
+The following example shows the use of `posflag.Provider`, a wrapper over the [spf13/pflag](https://github.com/spf13/pflag) library, an advanced commandline lib. For Go's built in `flag` package, use `basicflag.Provider`.
+
+```go
+package main
+
+import (
+ "fmt"
+ "log"
+ "os"
+
+ "github.com/knadh/koanf/v2"
+ "github.com/knadh/koanf/parsers/toml"
+
+ // TOML version 2 is available at:
+ // "github.com/knadh/koanf/parsers/toml/v2"
+
+ "github.com/knadh/koanf/providers/file"
+ "github.com/knadh/koanf/providers/posflag"
+ flag "github.com/spf13/pflag"
+)
+
+// Global koanf instance. Use "." as the key path delimiter. This can be "/" or any character.
+var k = koanf.New(".")
+
+func main() {
+ // Use the POSIX compliant pflag lib instead of Go's flag lib.
+ f := flag.NewFlagSet("config", flag.ContinueOnError)
+ f.Usage = func() {
+ fmt.Println(f.FlagUsages())
+ os.Exit(0)
+ }
+ // Path to one or more config files to load into koanf along with some config params.
+ f.StringSlice("conf", []string{"mock/mock.toml"}, "path to one or more .toml config files")
+ f.String("time", "2020-01-01", "a time string")
+ f.String("type", "xxx", "type of the app")
+ f.Parse(os.Args[1:])
+
+ // Load the config files provided in the commandline.
+ cFiles, _ := f.GetStringSlice("conf")
+ for _, c := range cFiles {
+ if err := k.Load(file.Provider(c), toml.Parser()); err != nil {
+ log.Fatalf("error loading file: %v", err)
+ }
+ }
+
+ // "time" and "type" may have been loaded from the config file, but
+ // they can still be overridden with the values from the command line.
+ // The bundled posflag.Provider takes a flagset from the spf13/pflag lib.
+ // Passing the Koanf instance to posflag helps it deal with default command
+ // line flag values that are not present in conf maps from previously loaded
+ // providers.
+ if err := k.Load(posflag.Provider(f, ".", k), nil); err != nil {
+ log.Fatalf("error loading config: %v", err)
+ }
+
+ fmt.Println("time is = ", k.String("time"))
+}
+```
+
+### Reading environment variables
+
+```go
+package main
+
+import (
+ "fmt"
+ "log"
+ "strings"
+
+ "github.com/knadh/koanf/v2"
+ "github.com/knadh/koanf/parsers/json"
+ "github.com/knadh/koanf/providers/env"
+ "github.com/knadh/koanf/providers/file"
+)
+
+// Global koanf instance. Use . as the key path delimiter. This can be / or anything.
+var k = koanf.New(".")
+
+func main() {
+ // Load JSON config.
+ if err := k.Load(file.Provider("mock/mock.json"), json.Parser()); err != nil {
+ log.Fatalf("error loading config: %v", err)
+ }
+
+ // Load environment variables and merge into the loaded config.
+ // "MYVAR" is the prefix to filter the env vars by.
+ // "." is the delimiter used to represent the key hierarchy in env vars.
+ // The (optional, or can be nil) function can be used to transform
+ // the env var names, for instance, to lowercase them.
+ //
+ // For example, env vars: MYVAR_TYPE and MYVAR_PARENT1_CHILD1_NAME
+ // will be merged into the "type" and the nested "parent1.child1.name"
+ // keys in the config file here as we lowercase the key,
+ // replace `_` with `.` and strip the MYVAR_ prefix so that
+ // only "parent1.child1.name" remains.
+ k.Load(env.Provider("MYVAR_", ".", func(s string) string {
+ return strings.Replace(strings.ToLower(
+ strings.TrimPrefix(s, "MYVAR_")), "_", ".", -1)
+ }), nil)
+
+ fmt.Println("name is = ", k.String("parent1.child1.name"))
+}
+```
+
+You can also use the `env.ProviderWithValue` with a callback that supports mutating both the key and value
+to return types other than a string. For example, here, env values separated by spaces are
+returned as string slices or arrays. eg: `MYVAR_slice=a b c` becomes `slice: [a, b, c]`.
+
+```go
+ k.Load(env.ProviderWithValue("MYVAR_", ".", func(s string, v string) (string, interface{}) {
+ // Strip out the MYVAR_ prefix and lowercase and get the key while also replacing
+ // the _ character with . in the key (koanf delimeter).
+ key := strings.Replace(strings.ToLower(strings.TrimPrefix(s, "MYVAR_")), "_", ".", -1)
+
+ // If there is a space in the value, split the value into a slice by the space.
+ if strings.Contains(v, " ") {
+ return key, strings.Split(v, " ")
+ }
+
+ // Otherwise, return the plain string.
+ return key, v
+ }), nil)
+```
+
+### Reading from an S3 bucket
+
+```go
+// Load JSON config from s3.
+if err := k.Load(s3.Provider(s3.Config{
+ AccessKey: os.Getenv("AWS_S3_ACCESS_KEY"),
+ SecretKey: os.Getenv("AWS_S3_SECRET_KEY"),
+ Region: os.Getenv("AWS_S3_REGION"),
+ Bucket: os.Getenv("AWS_S3_BUCKET"),
+ ObjectKey: "dir/config.json",
+}), json.Parser()); err != nil {
+ log.Fatalf("error loading config: %v", err)
+}
+```
+
+### Reading raw bytes
+
+The bundled `rawbytes` Provider can be used to read arbitrary bytes from a source, like a database or an HTTP call.
+
+```go
+package main
+
+import (
+ "fmt"
+
+ "github.com/knadh/koanf/v2"
+ "github.com/knadh/koanf/parsers/json"
+ "github.com/knadh/koanf/providers/rawbytes"
+)
+
+// Global koanf instance. Use . as the key path delimiter. This can be / or anything.
+var k = koanf.New(".")
+
+func main() {
+ b := []byte(`{"type": "rawbytes", "parent1": {"child1": {"type": "rawbytes"}}}`)
+ k.Load(rawbytes.Provider(b), json.Parser())
+ fmt.Println("type is = ", k.String("parent1.child1.type"))
+}
+```
+
+### Unmarshalling and marshalling
+`Parser`s can be used to unmarshal and scan the values in a Koanf instance into a struct based on the field tags, and to marshal a Koanf instance back into serialized bytes, for example to JSON or YAML files
+
+```go
+package main
+
+import (
+ "fmt"
+ "log"
+
+ "github.com/knadh/koanf/v2"
+ "github.com/knadh/koanf/parsers/json"
+ "github.com/knadh/koanf/providers/file"
+)
+
+// Global koanf instance. Use . as the key path delimiter. This can be / or anything.
+var (
+ k = koanf.New(".")
+ parser = json.Parser()
+)
+
+func main() {
+ // Load JSON config.
+ if err := k.Load(file.Provider("mock/mock.json"), parser); err != nil {
+ log.Fatalf("error loading config: %v", err)
+ }
+
+ // Structure to unmarshal nested conf to.
+ type childStruct struct {
+ Name string `koanf:"name"`
+ Type string `koanf:"type"`
+ Empty map[string]string `koanf:"empty"`
+ GrandChild struct {
+ Ids []int `koanf:"ids"`
+ On bool `koanf:"on"`
+ } `koanf:"grandchild1"`
+ }
+
+ var out childStruct
+
+ // Quick unmarshal.
+ k.Unmarshal("parent1.child1", &out)
+ fmt.Println(out)
+
+ // Unmarshal with advanced config.
+ out = childStruct{}
+ k.UnmarshalWithConf("parent1.child1", &out, koanf.UnmarshalConf{Tag: "koanf"})
+ fmt.Println(out)
+
+ // Marshal the instance back to JSON.
+ // The parser instance can be anything, eg: json.Parser(), yaml.Parser() etc.
+ b, _ := k.Marshal(parser)
+ fmt.Println(string(b))
+}
+```
+
+### Unmarshalling with flat paths
+
+Sometimes it is necessary to unmarshal an assortment of keys from various nested structures into a flat target structure. This is possible with the `UnmarshalConf.FlatPaths` flag.
+
+```go
+package main
+
+import (
+ "fmt"
+ "log"
+
+ "github.com/knadh/koanf/v2"
+ "github.com/knadh/koanf/parsers/json"
+ "github.com/knadh/koanf/providers/file"
+)
+
+// Global koanf instance. Use . as the key path delimiter. This can be / or anything.
+var k = koanf.New(".")
+
+func main() {
+ // Load JSON config.
+ if err := k.Load(file.Provider("mock/mock.json"), json.Parser()); err != nil {
+ log.Fatalf("error loading config: %v", err)
+ }
+
+ type rootFlat struct {
+ Type string `koanf:"type"`
+ Empty map[string]string `koanf:"empty"`
+ Parent1Name string `koanf:"parent1.name"`
+ Parent1ID int `koanf:"parent1.id"`
+ Parent1Child1Name string `koanf:"parent1.child1.name"`
+ Parent1Child1Type string `koanf:"parent1.child1.type"`
+ Parent1Child1Empty map[string]string `koanf:"parent1.child1.empty"`
+ Parent1Child1Grandchild1IDs []int `koanf:"parent1.child1.grandchild1.ids"`
+ Parent1Child1Grandchild1On bool `koanf:"parent1.child1.grandchild1.on"`
+ }
+
+ // Unmarshal the whole root with FlatPaths: True.
+ var o1 rootFlat
+ k.UnmarshalWithConf("", &o1, koanf.UnmarshalConf{Tag: "koanf", FlatPaths: true})
+ fmt.Println(o1)
+
+ // Unmarshal a child structure of "parent1".
+ type subFlat struct {
+ Name string `koanf:"name"`
+ ID int `koanf:"id"`
+ Child1Name string `koanf:"child1.name"`
+ Child1Type string `koanf:"child1.type"`
+ Child1Empty map[string]string `koanf:"child1.empty"`
+ Child1Grandchild1IDs []int `koanf:"child1.grandchild1.ids"`
+ Child1Grandchild1On bool `koanf:"child1.grandchild1.on"`
+ }
+
+ var o2 subFlat
+ k.UnmarshalWithConf("parent1", &o2, koanf.UnmarshalConf{Tag: "koanf", FlatPaths: true})
+ fmt.Println(o2)
+}
+```
+
+#### Reading from nested maps
+
+The bundled `confmap` provider takes a `map[string]interface{}` that can be loaded into a koanf instance.
+
+```go
+package main
+
+import (
+ "fmt"
+ "log"
+
+ "github.com/knadh/koanf/v2"
+ "github.com/knadh/koanf/providers/confmap"
+ "github.com/knadh/koanf/providers/file"
+ "github.com/knadh/koanf/parsers/json"
+ "github.com/knadh/koanf/parsers/yaml"
+)
+
+// Global koanf instance. Use "." as the key path delimiter. This can be "/" or any character.
+var k = koanf.New(".")
+
+func main() {
+ // Load default values using the confmap provider.
+ // We provide a flat map with the "." delimiter.
+ // A nested map can be loaded by setting the delimiter to an empty string "".
+ k.Load(confmap.Provider(map[string]interface{}{
+ "parent1.name": "Default Name",
+ "parent3.name": "New name here",
+ }, "."), nil)
+
+ // Load JSON config on top of the default values.
+ if err := k.Load(file.Provider("mock/mock.json"), json.Parser()); err != nil {
+ log.Fatalf("error loading config: %v", err)
+ }
+
+ // Load YAML config and merge into the previously loaded config (because we can).
+ k.Load(file.Provider("mock/mock.yml"), yaml.Parser())
+
+ fmt.Println("parent's name is = ", k.String("parent1.name"))
+ fmt.Println("parent's ID is = ", k.Int("parent1.id"))
+}
+```
+
+#### Reading from struct
+
+The bundled `structs` provider can be used to read data from a struct to load into a koanf instance.
+
+```go
+package main
+
+import (
+ "fmt"
+
+ "github.com/knadh/koanf/v2"
+ "github.com/knadh/koanf/providers/structs"
+)
+
+// Global koanf instance. Use "." as the key path delimiter. This can be "/" or any character.
+var k = koanf.New(".")
+
+type parentStruct struct {
+ Name string `koanf:"name"`
+ ID int `koanf:"id"`
+ Child1 childStruct `koanf:"child1"`
+}
+type childStruct struct {
+ Name string `koanf:"name"`
+ Type string `koanf:"type"`
+ Empty map[string]string `koanf:"empty"`
+ Grandchild1 grandchildStruct `koanf:"grandchild1"`
+}
+type grandchildStruct struct {
+ Ids []int `koanf:"ids"`
+ On bool `koanf:"on"`
+}
+type sampleStruct struct {
+ Type string `koanf:"type"`
+ Empty map[string]string `koanf:"empty"`
+ Parent1 parentStruct `koanf:"parent1"`
+}
+
+func main() {
+ // Load default values using the structs provider.
+ // We provide a struct along with the struct tag `koanf` to the
+ // provider.
+ k.Load(structs.Provider(sampleStruct{
+ Type: "json",
+ Empty: make(map[string]string),
+ Parent1: parentStruct{
+ Name: "parent1",
+ ID: 1234,
+ Child1: childStruct{
+ Name: "child1",
+ Type: "json",
+ Empty: make(map[string]string),
+ Grandchild1: grandchildStruct{
+ Ids: []int{1, 2, 3},
+ On: true,
+ },
+ },
+ },
+ }, "koanf"), nil)
+
+ fmt.Printf("name is = `%s`\n", k.String("parent1.child1.name"))
+}
+```
+### Merge behavior
+#### Default behavior
+The default behavior when you create Koanf this way is: `koanf.New(delim)` that the latest loaded configuration will
+merge with the previous one.
+
+For example:
+`first.yml`
+```yaml
+key: [1,2,3]
+```
+`second.yml`
+```yaml
+key: 'string'
+```
+When `second.yml` is loaded it will override the type of the `first.yml`.
+
+If this behavior is not desired, you can merge 'strictly'. In the same scenario, `Load` will return an error.
+
+```go
+package main
+
+import (
+ "errors"
+ "log"
+
+ "github.com/knadh/koanf/v2"
+ "github.com/knadh/koanf/maps"
+ "github.com/knadh/koanf/parsers/json"
+ "github.com/knadh/koanf/parsers/yaml"
+ "github.com/knadh/koanf/providers/file"
+)
+
+var conf = koanf.Conf{
+ Delim: ".",
+ StrictMerge: true,
+}
+var k = koanf.NewWithConf(conf)
+
+func main() {
+ yamlPath := "mock/mock.yml"
+ if err := k.Load(file.Provider(yamlPath), yaml.Parser()); err != nil {
+ log.Fatalf("error loading config: %v", err)
+ }
+
+ jsonPath := "mock/mock.json"
+ if err := k.Load(file.Provider(jsonPath), json.Parser()); err != nil {
+ log.Fatalf("error loading config: %v", err)
+ }
+}
+```
+**Note:** When merging different extensions, each parser can treat his types differently,
+ meaning even though you the load same types there is a probability that it will fail with `StrictMerge: true`.
+
+For example: merging JSON and YAML will most likely fail because JSON treats integers as float64 and YAML treats them as integers.
+
+### Order of merge and key case sensitivity
+
+- Config keys are case-sensitive in koanf. For example, `app.server.port` and `APP.SERVER.port` are not the same.
+- koanf does not impose any ordering on loading config from various providers. Every successive `Load()` or `Merge()` merges new config into the existing config. That is, it is possible to load environment variables first, then files on top of it, and then command line variables on top of it, or any such order.
+
+### Custom Providers and Parsers
+
+A Provider returns a nested `map[string]interface{}` config that can be loaded directly into koanf with `koanf.Load()` or it can return raw bytes that can be parsed with a Parser (again, loaded using `koanf.Load()`. Writing Providers and Parsers are easy. See the bundled implementations in the [providers](https://github.com/knadh/koanf/tree/master/providers) and [parsers](https://github.com/knadh/koanf/tree/master/parsers) directories.
+
+### Custom merge strategies
+
+By default, when merging two config sources using `Load()`, koanf recursively merges keys of nested maps (`map[string]interface{}`),
+while static values are overwritten (slices, strings, etc). This behaviour can be changed by providing a custom merge function with the `WithMergeFunc` option.
+
+```go
+package main
+
+import (
+ "errors"
+ "log"
+
+ "github.com/knadh/koanf/v2"
+ "github.com/knadh/koanf/maps"
+ "github.com/knadh/koanf/parsers/json"
+ "github.com/knadh/koanf/parsers/yaml"
+ "github.com/knadh/koanf/providers/file"
+)
+
+var conf = koanf.Conf{
+ Delim: ".",
+ StrictMerge: true,
+}
+var k = koanf.NewWithConf(conf)
+
+func main() {
+ yamlPath := "mock/mock.yml"
+ if err := k.Load(file.Provider(yamlPath), yaml.Parser()); err != nil {
+ log.Fatalf("error loading config: %v", err)
+ }
+
+ jsonPath := "mock/mock.json"
+ if err := k.Load(file.Provider(jsonPath), json.Parser(), koanf.WithMergeFunc(func(src, dest map[string]interface{}) error {
+ // Your custom logic, copying values from src into dst
+ return nil
+ })); err != nil {
+ log.Fatalf("error loading config: %v", err)
+ }
+}
+```
+
+## API
+
+See the full API documentation of all available methods at https://pkg.go.dev/github.com/knadh/koanf/v2#section-documentation
+
+### Bundled Providers
+
+Install with `go get -u github.com/knadh/koanf/providers/$provider`
+
+| Package | Provider | Description |
+| ------------------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| file | `file.Provider(filepath string)` | Reads a file and returns the raw bytes to be parsed. |
+| fs | `fs.Provider(f fs.FS, filepath string)` | (**Experimental**) Reads a file from fs.FS and returns the raw bytes to be parsed. The provider requires `go v1.16` or higher. |
+| basicflag | `basicflag.Provider(f *flag.FlagSet, delim string)` | Takes an stdlib `flag.FlagSet` |
+| posflag | `posflag.Provider(f *pflag.FlagSet, delim string)` | Takes an `spf13/pflag.FlagSet` (advanced POSIX compatible flags with multiple types) and provides a nested config map based on delim. |
+| env | `env.Provider(prefix, delim string, f func(s string) string)` | Takes an optional prefix to filter env variables by, an optional function that takes and returns a string to transform env variables, and returns a nested config map based on delim. |
+| confmap | `confmap.Provider(mp map[string]interface{}, delim string)` | Takes a premade `map[string]interface{}` conf map. If delim is provided, the keys are assumed to be flattened, thus unflattened using delim. |
+| structs | `structs.Provider(s interface{}, tag string)` | Takes a struct and struct tag. |
+| s3 | `s3.Provider(s3.S3Config{})` | Takes a s3 config struct. |
+| rawbytes | `rawbytes.Provider(b []byte)` | Takes a raw `[]byte` slice to be parsed with a koanf.Parser |
+| vault/v2 | `vault.Provider(vault.Config{})` | Hashicorp Vault provider |
+| appconfig/v2 | `vault.AppConfig(appconfig.Config{})` | AWS AppConfig provider |
+| etcd/v2 | `etcd.Provider(etcd.Config{})` | CNCF etcd provider |
+| consul/v2 | `consul.Provider(consul.Config{})` | Hashicorp Consul provider |
+| parameterstore/v2 | `parameterstore.Provider(parameterstore.Config{})` | AWS Systems Manager Parameter Store provider |
+
+
+### Bundled Parsers
+
+Install with `go get -u github.com/knadh/koanf/parsers/$parser`
+
+| Package | Parser | Description |
+| ------------ | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| json | `json.Parser()` | Parses JSON bytes into a nested map |
+| yaml | `yaml.Parser()` | Parses YAML bytes into a nested map |
+| toml | `toml.Parser()` | Parses TOML bytes into a nested map |
+| toml/v2 | `toml.Parser()` | Parses TOML bytes into a nested map (using go-toml v2) |
+| dotenv | `dotenv.Parser()` | Parses DotEnv bytes into a flat map |
+| hcl | `hcl.Parser(flattenSlices bool)` | Parses Hashicorp HCL bytes into a nested map. `flattenSlices` is recommended to be set to true. [Read more](https://github.com/hashicorp/hcl/issues/162). |
+| nestedtext | `nestedtext.Parser()` | Parses NestedText bytes into a flat map |
+| hjson | `hjson.Parser()` | Parses HJSON bytes into a nested map
+ |
+
+
+### Third-party Providers
+| Package | Provider | Description |
+| ------------------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| github.com/defensestation/koanf/providers/secretsmanager | `vault.SecretsMananger(secretsmanager.Config{}, f func(s string) string)` | AWS Secrets Manager provider, takes map or string as a value from store |
+| github.com/defensestation/koanf/providers/parameterstore | `vault.ParameterStore(parameterstore.Config{}, f func(s string) string)` | AWS ParameterStore provider, an optional function that takes and returns a string to transform env variables |
+
+
+### Alternative to viper
+
+koanf is a [lightweight](https://github.com/knadh/koanf/blob/master/go.mod) alternative to the popular [spf13/viper](https://github.com/spf13/viper). It was written as a result of multiple stumbling blocks encountered with some of viper's fundamental flaws.
+
+- viper breaks JSON, YAML, TOML, HCL language specs by [forcibly lowercasing keys](https://github.com/spf13/viper/pull/635).
+- Significantly bloats [build sizes](https://github.com/knadh/koanf/wiki/Comparison-with-spf13-viper).
+- Tightly couples config parsing with file extensions.
+- Has poor semantics and abstractions. Commandline, env, file etc. and various parses are hardcoded in the core. There are no primitives that can be extended.
+- Pulls a large number of [third party dependencies](https://github.com/spf13/viper/issues/707) into the core package. For instance, even if you do not use YAML or flags, the dependencies are still pulled as a result of the coupling.
+- Imposes arbitrary ordering conventions (eg: flag -> env -> config etc.)
+- `Get()` returns references to slices and maps. Mutations made outside change the underlying values inside the conf map.
+- Does non-idiomatic things such as [throwing away O(1) on flat maps](https://github.com/spf13/viper/blob/3b4aca75714a37276c4b1883630bd98c02498b73/viper.go#L1524).
+- Viper treats keys that contain an empty map (eg: `my_key: {}`) as if they were not set (ie: `IsSet("my_key") == false`).
+- There are a large number of [open issues](https://github.com/spf13/viper/issues).
diff --git a/vendor/github.com/knadh/koanf/v2/getters.go b/vendor/github.com/knadh/koanf/v2/getters.go
new file mode 100644
index 0000000000..266230f747
--- /dev/null
+++ b/vendor/github.com/knadh/koanf/v2/getters.go
@@ -0,0 +1,649 @@
+package koanf
+
+import (
+ "fmt"
+ "time"
+)
+
+// Int64 returns the int64 value of a given key path or 0 if the path
+// does not exist or if the value is not a valid int64.
+func (ko *Koanf) Int64(path string) int64 {
+ if v := ko.Get(path); v != nil {
+ i, _ := toInt64(v)
+ return i
+ }
+ return 0
+}
+
+// MustInt64 returns the int64 value of a given key path or panics
+// if the value is not set or set to default value of 0.
+func (ko *Koanf) MustInt64(path string) int64 {
+ val := ko.Int64(path)
+ if val == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// Int64s returns the []int64 slice value of a given key path or an
+// empty []int64 slice if the path does not exist or if the value
+// is not a valid int slice.
+func (ko *Koanf) Int64s(path string) []int64 {
+ o := ko.Get(path)
+ if o == nil {
+ return []int64{}
+ }
+
+ var out []int64
+ switch v := o.(type) {
+ case []int64:
+ return v
+ case []int:
+ out = make([]int64, 0, len(v))
+ for _, vi := range v {
+ i, err := toInt64(vi)
+
+ // On error, return as it's not a valid
+ // int slice.
+ if err != nil {
+ return []int64{}
+ }
+ out = append(out, i)
+ }
+ return out
+ case []interface{}:
+ out = make([]int64, 0, len(v))
+ for _, vi := range v {
+ i, err := toInt64(vi)
+
+ // On error, return as it's not a valid
+ // int slice.
+ if err != nil {
+ return []int64{}
+ }
+ out = append(out, i)
+ }
+ return out
+ }
+
+ return []int64{}
+}
+
+// MustInt64s returns the []int64 slice value of a given key path or panics
+// if the value is not set or its default value.
+func (ko *Koanf) MustInt64s(path string) []int64 {
+ val := ko.Int64s(path)
+ if len(val) == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// Int64Map returns the map[string]int64 value of a given key path
+// or an empty map[string]int64 if the path does not exist or if the
+// value is not a valid int64 map.
+func (ko *Koanf) Int64Map(path string) map[string]int64 {
+ var (
+ out = map[string]int64{}
+ o = ko.Get(path)
+ )
+ if o == nil {
+ return out
+ }
+
+ mp, ok := o.(map[string]interface{})
+ if !ok {
+ return out
+ }
+
+ out = make(map[string]int64, len(mp))
+ for k, v := range mp {
+ switch i := v.(type) {
+ case int64:
+ out[k] = i
+ default:
+ // Attempt a conversion.
+ iv, err := toInt64(i)
+ if err != nil {
+ return map[string]int64{}
+ }
+ out[k] = iv
+ }
+ }
+ return out
+}
+
+// MustInt64Map returns the map[string]int64 value of a given key path
+// or panics if it isn't set or set to default value.
+func (ko *Koanf) MustInt64Map(path string) map[string]int64 {
+ val := ko.Int64Map(path)
+ if len(val) == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// Int returns the int value of a given key path or 0 if the path
+// does not exist or if the value is not a valid int.
+func (ko *Koanf) Int(path string) int {
+ return int(ko.Int64(path))
+}
+
+// MustInt returns the int value of a given key path or panics
+// if it isn't set or set to default value of 0.
+func (ko *Koanf) MustInt(path string) int {
+ val := ko.Int(path)
+ if val == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// Ints returns the []int slice value of a given key path or an
+// empty []int slice if the path does not exist or if the value
+// is not a valid int slice.
+func (ko *Koanf) Ints(path string) []int {
+ o := ko.Get(path)
+ if o == nil {
+ return []int{}
+ }
+
+ var out []int
+ switch v := o.(type) {
+ case []int:
+ return v
+ case []int64:
+ out = make([]int, 0, len(v))
+ for _, vi := range v {
+ out = append(out, int(vi))
+ }
+ return out
+ case []interface{}:
+ out = make([]int, 0, len(v))
+ for _, vi := range v {
+ i, err := toInt64(vi)
+
+ // On error, return as it's not a valid
+ // int slice.
+ if err != nil {
+ return []int{}
+ }
+ out = append(out, int(i))
+ }
+ return out
+ }
+
+ return []int{}
+}
+
+// MustInts returns the []int slice value of a given key path or panics
+// if the value is not set or set to default value.
+func (ko *Koanf) MustInts(path string) []int {
+ val := ko.Ints(path)
+ if len(val) == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// IntMap returns the map[string]int value of a given key path
+// or an empty map[string]int if the path does not exist or if the
+// value is not a valid int map.
+func (ko *Koanf) IntMap(path string) map[string]int {
+ var (
+ mp = ko.Int64Map(path)
+ out = make(map[string]int, len(mp))
+ )
+ for k, v := range mp {
+ out[k] = int(v)
+ }
+ return out
+}
+
+// MustIntMap returns the map[string]int value of a given key path or panics
+// if the value is not set or set to default value.
+func (ko *Koanf) MustIntMap(path string) map[string]int {
+ val := ko.IntMap(path)
+ if len(val) == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// Float64 returns the float64 value of a given key path or 0 if the path
+// does not exist or if the value is not a valid float64.
+func (ko *Koanf) Float64(path string) float64 {
+ if v := ko.Get(path); v != nil {
+ f, _ := toFloat64(v)
+ return f
+ }
+ return 0
+}
+
+// MustFloat64 returns the float64 value of a given key path or panics
+// if it isn't set or set to default value 0.
+func (ko *Koanf) MustFloat64(path string) float64 {
+ val := ko.Float64(path)
+ if val == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// Float64s returns the []float64 slice value of a given key path or an
+// empty []float64 slice if the path does not exist or if the value
+// is not a valid float64 slice.
+func (ko *Koanf) Float64s(path string) []float64 {
+ o := ko.Get(path)
+ if o == nil {
+ return []float64{}
+ }
+
+ var out []float64
+ switch v := o.(type) {
+ case []float64:
+ return v
+ case []interface{}:
+ out = make([]float64, 0, len(v))
+ for _, vi := range v {
+ i, err := toFloat64(vi)
+
+ // On error, return as it's not a valid
+ // int slice.
+ if err != nil {
+ return []float64{}
+ }
+ out = append(out, i)
+ }
+ return out
+ }
+
+ return []float64{}
+}
+
+// MustFloat64s returns the []Float64 slice value of a given key path or panics
+// if the value is not set or set to default value.
+func (ko *Koanf) MustFloat64s(path string) []float64 {
+ val := ko.Float64s(path)
+ if len(val) == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// Float64Map returns the map[string]float64 value of a given key path
+// or an empty map[string]float64 if the path does not exist or if the
+// value is not a valid float64 map.
+func (ko *Koanf) Float64Map(path string) map[string]float64 {
+ var (
+ out = map[string]float64{}
+ o = ko.Get(path)
+ )
+ if o == nil {
+ return out
+ }
+
+ mp, ok := o.(map[string]interface{})
+ if !ok {
+ return out
+ }
+
+ out = make(map[string]float64, len(mp))
+ for k, v := range mp {
+ switch i := v.(type) {
+ case float64:
+ out[k] = i
+ default:
+ // Attempt a conversion.
+ iv, err := toFloat64(i)
+ if err != nil {
+ return map[string]float64{}
+ }
+ out[k] = iv
+ }
+ }
+ return out
+}
+
+// MustFloat64Map returns the map[string]float64 value of a given key path or panics
+// if the value is not set or set to default value.
+func (ko *Koanf) MustFloat64Map(path string) map[string]float64 {
+ val := ko.Float64Map(path)
+ if len(val) == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// Duration returns the time.Duration value of a given key path assuming
+// that the key contains a valid numeric value.
+func (ko *Koanf) Duration(path string) time.Duration {
+ // Look for a parsable string representation first.
+ if v := ko.Int64(path); v != 0 {
+ return time.Duration(v)
+ }
+
+ v, _ := time.ParseDuration(ko.String(path))
+ return v
+}
+
+// MustDuration returns the time.Duration value of a given key path or panics
+// if it isn't set or set to default value 0.
+func (ko *Koanf) MustDuration(path string) time.Duration {
+ val := ko.Duration(path)
+ if val == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// Time attempts to parse the value of a given key path and return time.Time
+// representation. If the value is numeric, it is treated as a UNIX timestamp
+// and if it's string, a parse is attempted with the given layout.
+func (ko *Koanf) Time(path, layout string) time.Time {
+ // Unix timestamp?
+ v := ko.Int64(path)
+ if v != 0 {
+ return time.Unix(v, 0)
+ }
+
+ // String representation.
+ s := ko.String(path)
+ if s != "" {
+ t, _ := time.Parse(layout, s)
+ return t
+ }
+
+ return time.Time{}
+}
+
+// MustTime attempts to parse the value of a given key path and return time.Time
+// representation. If the value is numeric, it is treated as a UNIX timestamp
+// and if it's string, a parse is attempted with the given layout. It panics if
+// the parsed time is zero.
+func (ko *Koanf) MustTime(path, layout string) time.Time {
+ val := ko.Time(path, layout)
+ if val.IsZero() {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// String returns the string value of a given key path or "" if the path
+// does not exist or if the value is not a valid string.
+func (ko *Koanf) String(path string) string {
+ if v := ko.Get(path); v != nil {
+ if i, ok := v.(string); ok {
+ return i
+ }
+ return fmt.Sprintf("%v", v)
+ }
+ return ""
+}
+
+// MustString returns the string value of a given key path
+// or panics if it isn't set or set to default value "".
+func (ko *Koanf) MustString(path string) string {
+ val := ko.String(path)
+ if val == "" {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// Strings returns the []string slice value of a given key path or an
+// empty []string slice if the path does not exist or if the value
+// is not a valid string slice.
+func (ko *Koanf) Strings(path string) []string {
+ o := ko.Get(path)
+ if o == nil {
+ return []string{}
+ }
+
+ var out []string
+ switch v := o.(type) {
+ case []interface{}:
+ out = make([]string, 0, len(v))
+ for _, u := range v {
+ if s, ok := u.(string); ok {
+ out = append(out, s)
+ } else {
+ out = append(out, fmt.Sprintf("%v", u))
+ }
+ }
+ return out
+ case []string:
+ out := make([]string, len(v))
+ copy(out, v)
+ return out
+ }
+
+ return []string{}
+}
+
+// MustStrings returns the []string slice value of a given key path or panics
+// if the value is not set or set to default value.
+func (ko *Koanf) MustStrings(path string) []string {
+ val := ko.Strings(path)
+ if len(val) == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// StringMap returns the map[string]string value of a given key path
+// or an empty map[string]string if the path does not exist or if the
+// value is not a valid string map.
+func (ko *Koanf) StringMap(path string) map[string]string {
+ var (
+ out = map[string]string{}
+ o = ko.Get(path)
+ )
+ if o == nil {
+ return out
+ }
+
+ switch mp := o.(type) {
+ case map[string]string:
+ out = make(map[string]string, len(mp))
+ for k, v := range mp {
+ out[k] = v
+ }
+ case map[string]interface{}:
+ out = make(map[string]string, len(mp))
+ for k, v := range mp {
+ switch s := v.(type) {
+ case string:
+ out[k] = s
+ default:
+ // There's a non string type. Return.
+ return map[string]string{}
+ }
+ }
+ }
+
+ return out
+}
+
+// MustStringMap returns the map[string]string value of a given key path or panics
+// if the value is not set or set to default value.
+func (ko *Koanf) MustStringMap(path string) map[string]string {
+ val := ko.StringMap(path)
+ if len(val) == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// StringsMap returns the map[string][]string value of a given key path
+// or an empty map[string][]string if the path does not exist or if the
+// value is not a valid strings map.
+func (ko *Koanf) StringsMap(path string) map[string][]string {
+ var (
+ out = map[string][]string{}
+ o = ko.Get(path)
+ )
+ if o == nil {
+ return out
+ }
+
+ switch mp := o.(type) {
+ case map[string][]string:
+ out = make(map[string][]string, len(mp))
+ for k, v := range mp {
+ out[k] = append(out[k], v...)
+ }
+ case map[string][]interface{}:
+ out = make(map[string][]string, len(mp))
+ for k, v := range mp {
+ for _, v := range v {
+ switch sv := v.(type) {
+ case string:
+ out[k] = append(out[k], sv)
+ default:
+ return map[string][]string{}
+ }
+ }
+ }
+ case map[string]interface{}:
+ out = make(map[string][]string, len(mp))
+ for k, v := range mp {
+ switch s := v.(type) {
+ case []string:
+ out[k] = append(out[k], s...)
+ case []interface{}:
+ for _, v := range s {
+ switch sv := v.(type) {
+ case string:
+ out[k] = append(out[k], sv)
+ default:
+ return map[string][]string{}
+ }
+ }
+ default:
+ // There's a non []interface type. Return.
+ return map[string][]string{}
+ }
+ }
+ }
+
+ return out
+}
+
+// MustStringsMap returns the map[string][]string value of a given key path or panics
+// if the value is not set or set to default value.
+func (ko *Koanf) MustStringsMap(path string) map[string][]string {
+ val := ko.StringsMap(path)
+ if len(val) == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// Bytes returns the []byte value of a given key path or an empty
+// []byte slice if the path does not exist or if the value is not a valid string.
+func (ko *Koanf) Bytes(path string) []byte {
+ return []byte(ko.String(path))
+}
+
+// MustBytes returns the []byte value of a given key path or panics
+// if the value is not set or set to default value.
+func (ko *Koanf) MustBytes(path string) []byte {
+ val := ko.Bytes(path)
+ if len(val) == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// Bool returns the bool value of a given key path or false if the path
+// does not exist or if the value is not a valid bool representation.
+// Accepted string representations of bool are the ones supported by strconv.ParseBool.
+func (ko *Koanf) Bool(path string) bool {
+ if v := ko.Get(path); v != nil {
+ b, _ := toBool(v)
+ return b
+ }
+ return false
+}
+
+// Bools returns the []bool slice value of a given key path or an
+// empty []bool slice if the path does not exist or if the value
+// is not a valid bool slice.
+func (ko *Koanf) Bools(path string) []bool {
+ o := ko.Get(path)
+ if o == nil {
+ return []bool{}
+ }
+
+ var out []bool
+ switch v := o.(type) {
+ case []interface{}:
+ out = make([]bool, 0, len(v))
+ for _, u := range v {
+ b, err := toBool(u)
+ if err != nil {
+ return nil
+ }
+ out = append(out, b)
+ }
+ return out
+ case []bool:
+ return out
+ }
+ return nil
+}
+
+// MustBools returns the []bool value of a given key path or panics
+// if the value is not set or set to default value.
+func (ko *Koanf) MustBools(path string) []bool {
+ val := ko.Bools(path)
+ if len(val) == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
+
+// BoolMap returns the map[string]bool value of a given key path
+// or an empty map[string]bool if the path does not exist or if the
+// value is not a valid bool map.
+func (ko *Koanf) BoolMap(path string) map[string]bool {
+ var (
+ out = map[string]bool{}
+ o = ko.Get(path)
+ )
+ if o == nil {
+ return out
+ }
+
+ mp, ok := o.(map[string]interface{})
+ if !ok {
+ return out
+ }
+ out = make(map[string]bool, len(mp))
+ for k, v := range mp {
+ switch i := v.(type) {
+ case bool:
+ out[k] = i
+ default:
+ // Attempt a conversion.
+ b, err := toBool(i)
+ if err != nil {
+ return map[string]bool{}
+ }
+ out[k] = b
+ }
+ }
+
+ return out
+}
+
+// MustBoolMap returns the map[string]bool value of a given key path or panics
+// if the value is not set or set to default value.
+func (ko *Koanf) MustBoolMap(path string) map[string]bool {
+ val := ko.BoolMap(path)
+ if len(val) == 0 {
+ panic(fmt.Sprintf("invalid value: %s=%v", path, val))
+ }
+ return val
+}
diff --git a/vendor/github.com/knadh/koanf/v2/go.work b/vendor/github.com/knadh/koanf/v2/go.work
new file mode 100644
index 0000000000..b5337e02c9
--- /dev/null
+++ b/vendor/github.com/knadh/koanf/v2/go.work
@@ -0,0 +1,31 @@
+go 1.18
+
+use (
+ .
+ ./examples
+ ./maps
+ ./parsers/dotenv
+ ./parsers/hcl
+ ./parsers/hjson
+ ./parsers/json
+ ./parsers/kdl
+ ./parsers/nestedtext
+ ./parsers/toml
+ ./parsers/yaml
+ ./providers/appconfig
+ ./providers/basicflag
+ ./providers/confmap
+ ./providers/consul
+ ./providers/env
+ ./providers/etcd
+ ./providers/file
+ ./providers/fs
+ ./providers/nats
+ ./providers/parameterstore
+ ./providers/posflag
+ ./providers/rawbytes
+ ./providers/s3
+ ./providers/structs
+ ./providers/vault
+ ./tests
+)
diff --git a/vendor/github.com/knadh/koanf/v2/go.work.sum b/vendor/github.com/knadh/koanf/v2/go.work.sum
new file mode 100644
index 0000000000..eab7bcf845
--- /dev/null
+++ b/vendor/github.com/knadh/koanf/v2/go.work.sum
@@ -0,0 +1,154 @@
+cloud.google.com/go v0.110.0/go.mod h1:SJnCLqQ0FCFGSZMUNUf84MV3Aia54kn7pi8st7tMzaY=
+cloud.google.com/go/accessapproval v1.6.0/go.mod h1:R0EiYnwV5fsRFiKZkPHr6mwyk2wxUJ30nL4j2pcFY2E=
+cloud.google.com/go/accesscontextmanager v1.7.0/go.mod h1:CEGLewx8dwa33aDAZQujl7Dx+uYhS0eay198wB/VumQ=
+cloud.google.com/go/aiplatform v1.37.0/go.mod h1:IU2Cv29Lv9oCn/9LkFiiuKfwrRTq+QQMbW+hPCxJGZw=
+cloud.google.com/go/analytics v0.19.0/go.mod h1:k8liqf5/HCnOUkbawNtrWWc+UAzyDlW89doe8TtoDsE=
+cloud.google.com/go/apigateway v1.5.0/go.mod h1:GpnZR3Q4rR7LVu5951qfXPJCHquZt02jf7xQx7kpqN8=
+cloud.google.com/go/apigeeconnect v1.5.0/go.mod h1:KFaCqvBRU6idyhSNyn3vlHXc8VMDJdRmwDF6JyFRqZ8=
+cloud.google.com/go/apigeeregistry v0.6.0/go.mod h1:BFNzW7yQVLZ3yj0TKcwzb8n25CFBri51GVGOEUcgQsc=
+cloud.google.com/go/apikeys v0.6.0/go.mod h1:kbpXu5upyiAlGkKrJgQl8A0rKNNJ7dQ377pdroRSSi8=
+cloud.google.com/go/appengine v1.7.1/go.mod h1:IHLToyb/3fKutRysUlFO0BPt5j7RiQ45nrzEJmKTo6E=
+cloud.google.com/go/area120 v0.7.1/go.mod h1:j84i4E1RboTWjKtZVWXPqvK5VHQFJRF2c1Nm69pWm9k=
+cloud.google.com/go/artifactregistry v1.13.0/go.mod h1:uy/LNfoOIivepGhooAUpL1i30Hgee3Cu0l4VTWHUC08=
+cloud.google.com/go/asset v1.13.0/go.mod h1:WQAMyYek/b7NBpYq/K4KJWcRqzoalEsxz/t/dTk4THw=
+cloud.google.com/go/assuredworkloads v1.10.0/go.mod h1:kwdUQuXcedVdsIaKgKTp9t0UJkE5+PAVNhdQm4ZVq2E=
+cloud.google.com/go/automl v1.12.0/go.mod h1:tWDcHDp86aMIuHmyvjuKeeHEGq76lD7ZqfGLN6B0NuU=
+cloud.google.com/go/baremetalsolution v0.5.0/go.mod h1:dXGxEkmR9BMwxhzBhV0AioD0ULBmuLZI8CdwalUxuss=
+cloud.google.com/go/batch v0.7.0/go.mod h1:vLZN95s6teRUqRQ4s3RLDsH8PvboqBK+rn1oevL159g=
+cloud.google.com/go/beyondcorp v0.5.0/go.mod h1:uFqj9X+dSfrheVp7ssLTaRHd2EHqSL4QZmH4e8WXGGU=
+cloud.google.com/go/bigquery v1.50.0/go.mod h1:YrleYEh2pSEbgTBZYMJ5SuSr0ML3ypjRB1zgf7pvQLU=
+cloud.google.com/go/billing v1.13.0/go.mod h1:7kB2W9Xf98hP9Sr12KfECgfGclsH3CQR0R08tnRlRbc=
+cloud.google.com/go/binaryauthorization v1.5.0/go.mod h1:OSe4OU1nN/VswXKRBmciKpo9LulY41gch5c68htf3/Q=
+cloud.google.com/go/certificatemanager v1.6.0/go.mod h1:3Hh64rCKjRAX8dXgRAyOcY5vQ/fE1sh8o+Mdd6KPgY8=
+cloud.google.com/go/channel v1.12.0/go.mod h1:VkxCGKASi4Cq7TbXxlaBezonAYpp1GCnKMY6tnMQnLU=
+cloud.google.com/go/cloudbuild v1.9.0/go.mod h1:qK1d7s4QlO0VwfYn5YuClDGg2hfmLZEb4wQGAbIgL1s=
+cloud.google.com/go/clouddms v1.5.0/go.mod h1:QSxQnhikCLUw13iAbffF2CZxAER3xDGNHjsTAkQJcQA=
+cloud.google.com/go/cloudtasks v1.10.0/go.mod h1:NDSoTLkZ3+vExFEWu2UJV1arUyzVDAiZtdWcsUyNwBs=
+cloud.google.com/go/compute v1.19.1/go.mod h1:6ylj3a05WF8leseCdIf77NK0g1ey+nj5IKd5/kvShxE=
+cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA=
+cloud.google.com/go/contactcenterinsights v1.6.0/go.mod h1:IIDlT6CLcDoyv79kDv8iWxMSTZhLxSCofVV5W6YFM/w=
+cloud.google.com/go/container v1.15.0/go.mod h1:ft+9S0WGjAyjDggg5S06DXj+fHJICWg8L7isCQe9pQA=
+cloud.google.com/go/containeranalysis v0.9.0/go.mod h1:orbOANbwk5Ejoom+s+DUCTTJ7IBdBQJDcSylAx/on9s=
+cloud.google.com/go/datacatalog v1.13.0/go.mod h1:E4Rj9a5ZtAxcQJlEBTLgMTphfP11/lNaAshpoBgemX8=
+cloud.google.com/go/dataflow v0.8.0/go.mod h1:Rcf5YgTKPtQyYz8bLYhFoIV/vP39eL7fWNcSOyFfLJE=
+cloud.google.com/go/dataform v0.7.0/go.mod h1:7NulqnVozfHvWUBpMDfKMUESr+85aJsC/2O0o3jWPDE=
+cloud.google.com/go/datafusion v1.6.0/go.mod h1:WBsMF8F1RhSXvVM8rCV3AeyWVxcC2xY6vith3iw3S+8=
+cloud.google.com/go/datalabeling v0.7.0/go.mod h1:WPQb1y08RJbmpM3ww0CSUAGweL0SxByuW2E+FU+wXcM=
+cloud.google.com/go/dataplex v1.6.0/go.mod h1:bMsomC/aEJOSpHXdFKFGQ1b0TDPIeL28nJObeO1ppRs=
+cloud.google.com/go/dataproc v1.12.0/go.mod h1:zrF3aX0uV3ikkMz6z4uBbIKyhRITnxvr4i3IjKsKrw4=
+cloud.google.com/go/dataqna v0.7.0/go.mod h1:Lx9OcIIeqCrw1a6KdO3/5KMP1wAmTc0slZWwP12Qq3c=
+cloud.google.com/go/datastore v1.11.0/go.mod h1:TvGxBIHCS50u8jzG+AW/ppf87v1of8nwzFNgEZU1D3c=
+cloud.google.com/go/datastream v1.7.0/go.mod h1:uxVRMm2elUSPuh65IbZpzJNMbuzkcvu5CjMqVIUHrww=
+cloud.google.com/go/deploy v1.8.0/go.mod h1:z3myEJnA/2wnB4sgjqdMfgxCA0EqC3RBTNcVPs93mtQ=
+cloud.google.com/go/dialogflow v1.32.0/go.mod h1:jG9TRJl8CKrDhMEcvfcfFkkpp8ZhgPz3sBGmAUYJ2qE=
+cloud.google.com/go/dlp v1.9.0/go.mod h1:qdgmqgTyReTz5/YNSSuueR8pl7hO0o9bQ39ZhtgkWp4=
+cloud.google.com/go/documentai v1.18.0/go.mod h1:F6CK6iUH8J81FehpskRmhLq/3VlwQvb7TvwOceQ2tbs=
+cloud.google.com/go/domains v0.8.0/go.mod h1:M9i3MMDzGFXsydri9/vW+EWz9sWb4I6WyHqdlAk0idE=
+cloud.google.com/go/edgecontainer v1.0.0/go.mod h1:cttArqZpBB2q58W/upSG++ooo6EsblxDIolxa3jSjbY=
+cloud.google.com/go/errorreporting v0.3.0/go.mod h1:xsP2yaAp+OAW4OIm60An2bbLpqIhKXdWR/tawvl7QzU=
+cloud.google.com/go/essentialcontacts v1.5.0/go.mod h1:ay29Z4zODTuwliK7SnX8E86aUF2CTzdNtvv42niCX0M=
+cloud.google.com/go/eventarc v1.11.0/go.mod h1:PyUjsUKPWoRBCHeOxZd/lbOOjahV41icXyUY5kSTvVY=
+cloud.google.com/go/filestore v1.6.0/go.mod h1:di5unNuss/qfZTw2U9nhFqo8/ZDSc466dre85Kydllg=
+cloud.google.com/go/firestore v1.9.0/go.mod h1:HMkjKHNTtRyZNiMzu7YAsLr9K3X2udY2AMwDaMEQiiE=
+cloud.google.com/go/functions v1.13.0/go.mod h1:EU4O007sQm6Ef/PwRsI8N2umygGqPBS/IZQKBQBcJ3c=
+cloud.google.com/go/gaming v1.9.0/go.mod h1:Fc7kEmCObylSWLO334NcO+O9QMDyz+TKC4v1D7X+Bc0=
+cloud.google.com/go/gkebackup v0.4.0/go.mod h1:byAyBGUwYGEEww7xsbnUTBHIYcOPy/PgUWUtOeRm9Vg=
+cloud.google.com/go/gkeconnect v0.7.0/go.mod h1:SNfmVqPkaEi3bF/B3CNZOAYPYdg7sU+obZ+QTky2Myw=
+cloud.google.com/go/gkehub v0.12.0/go.mod h1:djiIwwzTTBrF5NaXCGv3mf7klpEMcST17VBTVVDcuaw=
+cloud.google.com/go/gkemulticloud v0.5.0/go.mod h1:W0JDkiyi3Tqh0TJr//y19wyb1yf8llHVto2Htf2Ja3Y=
+cloud.google.com/go/gsuiteaddons v1.5.0/go.mod h1:TFCClYLd64Eaa12sFVmUyG62tk4mdIsI7pAnSXRkcFo=
+cloud.google.com/go/iam v0.13.0/go.mod h1:ljOg+rcNfzZ5d6f1nAUJ8ZIxOaZUVoS14bKCtaLZ/D0=
+cloud.google.com/go/iap v1.7.1/go.mod h1:WapEwPc7ZxGt2jFGB/C/bm+hP0Y6NXzOYGjpPnmMS74=
+cloud.google.com/go/ids v1.3.0/go.mod h1:JBdTYwANikFKaDP6LtW5JAi4gubs57SVNQjemdt6xV4=
+cloud.google.com/go/iot v1.6.0/go.mod h1:IqdAsmE2cTYYNO1Fvjfzo9po179rAtJeVGUvkLN3rLE=
+cloud.google.com/go/kms v1.10.1/go.mod h1:rIWk/TryCkR59GMC3YtHtXeLzd634lBbKenvyySAyYI=
+cloud.google.com/go/language v1.9.0/go.mod h1:Ns15WooPM5Ad/5no/0n81yUetis74g3zrbeJBE+ptUY=
+cloud.google.com/go/lifesciences v0.8.0/go.mod h1:lFxiEOMqII6XggGbOnKiyZ7IBwoIqA84ClvoezaA/bo=
+cloud.google.com/go/logging v1.7.0/go.mod h1:3xjP2CjkM3ZkO73aj4ASA5wRPGGCRrPIAeNqVNkzY8M=
+cloud.google.com/go/longrunning v0.4.1/go.mod h1:4iWDqhBZ70CvZ6BfETbvam3T8FMvLK+eFj0E6AaRQTo=
+cloud.google.com/go/managedidentities v1.5.0/go.mod h1:+dWcZ0JlUmpuxpIDfyP5pP5y0bLdRwOS4Lp7gMni/LA=
+cloud.google.com/go/maps v0.7.0/go.mod h1:3GnvVl3cqeSvgMcpRlQidXsPYuDGQ8naBis7MVzpXsY=
+cloud.google.com/go/mediatranslation v0.7.0/go.mod h1:LCnB/gZr90ONOIQLgSXagp8XUW1ODs2UmUMvcgMfI2I=
+cloud.google.com/go/memcache v1.9.0/go.mod h1:8oEyzXCu+zo9RzlEaEjHl4KkgjlNDaXbCQeQWlzNFJM=
+cloud.google.com/go/metastore v1.10.0/go.mod h1:fPEnH3g4JJAk+gMRnrAnoqyv2lpUCqJPWOodSaf45Eo=
+cloud.google.com/go/monitoring v1.13.0/go.mod h1:k2yMBAB1H9JT/QETjNkgdCGD9bPF712XiLTVr+cBrpw=
+cloud.google.com/go/networkconnectivity v1.11.0/go.mod h1:iWmDD4QF16VCDLXUqvyspJjIEtBR/4zq5hwnY2X3scM=
+cloud.google.com/go/networkmanagement v1.6.0/go.mod h1:5pKPqyXjB/sgtvB5xqOemumoQNB7y95Q7S+4rjSOPYY=
+cloud.google.com/go/networksecurity v0.8.0/go.mod h1:B78DkqsxFG5zRSVuwYFRZ9Xz8IcQ5iECsNrPn74hKHU=
+cloud.google.com/go/notebooks v1.8.0/go.mod h1:Lq6dYKOYOWUCTvw5t2q1gp1lAp0zxAxRycayS0iJcqQ=
+cloud.google.com/go/optimization v1.3.1/go.mod h1:IvUSefKiwd1a5p0RgHDbWCIbDFgKuEdB+fPPuP0IDLI=
+cloud.google.com/go/orchestration v1.6.0/go.mod h1:M62Bevp7pkxStDfFfTuCOaXgaaqRAga1yKyoMtEoWPQ=
+cloud.google.com/go/orgpolicy v1.10.0/go.mod h1:w1fo8b7rRqlXlIJbVhOMPrwVljyuW5mqssvBtU18ONc=
+cloud.google.com/go/osconfig v1.11.0/go.mod h1:aDICxrur2ogRd9zY5ytBLV89KEgT2MKB2L/n6x1ooPw=
+cloud.google.com/go/oslogin v1.9.0/go.mod h1:HNavntnH8nzrn8JCTT5fj18FuJLFJc4NaZJtBnQtKFs=
+cloud.google.com/go/phishingprotection v0.7.0/go.mod h1:8qJI4QKHoda/sb/7/YmMQ2omRLSLYSu9bU0EKCNI+Lk=
+cloud.google.com/go/policytroubleshooter v1.6.0/go.mod h1:zYqaPTsmfvpjm5ULxAyD/lINQxJ0DDsnWOP/GZ7xzBc=
+cloud.google.com/go/privatecatalog v0.8.0/go.mod h1:nQ6pfaegeDAq/Q5lrfCQzQLhubPiZhSaNhIgfJlnIXs=
+cloud.google.com/go/pubsub v1.30.0/go.mod h1:qWi1OPS0B+b5L+Sg6Gmc9zD1Y+HaM0MdUr7LsupY1P4=
+cloud.google.com/go/pubsublite v1.7.0/go.mod h1:8hVMwRXfDfvGm3fahVbtDbiLePT3gpoiJYJY+vxWxVM=
+cloud.google.com/go/recaptchaenterprise/v2 v2.7.0/go.mod h1:19wVj/fs5RtYtynAPJdDTb69oW0vNHYDBTbB4NvMD9c=
+cloud.google.com/go/recommendationengine v0.7.0/go.mod h1:1reUcE3GIu6MeBz/h5xZJqNLuuVjNg1lmWMPyjatzac=
+cloud.google.com/go/recommender v1.9.0/go.mod h1:PnSsnZY7q+VL1uax2JWkt/UegHssxjUVVCrX52CuEmQ=
+cloud.google.com/go/redis v1.11.0/go.mod h1:/X6eicana+BWcUda5PpwZC48o37SiFVTFSs0fWAJ7uQ=
+cloud.google.com/go/resourcemanager v1.7.0/go.mod h1:HlD3m6+bwhzj9XCouqmeiGuni95NTrExfhoSrkC/3EI=
+cloud.google.com/go/resourcesettings v1.5.0/go.mod h1:+xJF7QSG6undsQDfsCJyqWXyBwUoJLhetkRMDRnIoXA=
+cloud.google.com/go/retail v1.12.0/go.mod h1:UMkelN/0Z8XvKymXFbD4EhFJlYKRx1FGhQkVPU5kF14=
+cloud.google.com/go/run v0.9.0/go.mod h1:Wwu+/vvg8Y+JUApMwEDfVfhetv30hCG4ZwDR/IXl2Qg=
+cloud.google.com/go/scheduler v1.9.0/go.mod h1:yexg5t+KSmqu+njTIh3b7oYPheFtBWGcbVUYF1GGMIc=
+cloud.google.com/go/secretmanager v1.10.0/go.mod h1:MfnrdvKMPNra9aZtQFvBcvRU54hbPD8/HayQdlUgJpU=
+cloud.google.com/go/security v1.13.0/go.mod h1:Q1Nvxl1PAgmeW0y3HTt54JYIvUdtcpYKVfIB8AOMZ+0=
+cloud.google.com/go/securitycenter v1.19.0/go.mod h1:LVLmSg8ZkkyaNy4u7HCIshAngSQ8EcIRREP3xBnyfag=
+cloud.google.com/go/servicecontrol v1.11.1/go.mod h1:aSnNNlwEFBY+PWGQ2DoM0JJ/QUXqV5/ZD9DOLB7SnUk=
+cloud.google.com/go/servicedirectory v1.9.0/go.mod h1:29je5JjiygNYlmsGz8k6o+OZ8vd4f//bQLtvzkPPT/s=
+cloud.google.com/go/servicemanagement v1.8.0/go.mod h1:MSS2TDlIEQD/fzsSGfCdJItQveu9NXnUniTrq/L8LK4=
+cloud.google.com/go/serviceusage v1.6.0/go.mod h1:R5wwQcbOWsyuOfbP9tGdAnCAc6B9DRwPG1xtWMDeuPA=
+cloud.google.com/go/shell v1.6.0/go.mod h1:oHO8QACS90luWgxP3N9iZVuEiSF84zNyLytb+qE2f9A=
+cloud.google.com/go/spanner v1.45.0/go.mod h1:FIws5LowYz8YAE1J8fOS7DJup8ff7xJeetWEo5REA2M=
+cloud.google.com/go/speech v1.15.0/go.mod h1:y6oH7GhqCaZANH7+Oe0BhgIogsNInLlz542tg3VqeYI=
+cloud.google.com/go/storagetransfer v1.8.0/go.mod h1:JpegsHHU1eXg7lMHkvf+KE5XDJ7EQu0GwNJbbVGanEw=
+cloud.google.com/go/talent v1.5.0/go.mod h1:G+ODMj9bsasAEJkQSzO2uHQWXHHXUomArjWQQYkqK6c=
+cloud.google.com/go/texttospeech v1.6.0/go.mod h1:YmwmFT8pj1aBblQOI3TfKmwibnsfvhIBzPXcW4EBovc=
+cloud.google.com/go/tpu v1.5.0/go.mod h1:8zVo1rYDFuW2l4yZVY0R0fb/v44xLh3llq7RuV61fPM=
+cloud.google.com/go/trace v1.9.0/go.mod h1:lOQqpE5IaWY0Ixg7/r2SjixMuc6lfTFeO4QGM4dQWOk=
+cloud.google.com/go/translate v1.7.0/go.mod h1:lMGRudH1pu7I3n3PETiOB2507gf3HnfLV8qlkHZEyos=
+cloud.google.com/go/video v1.15.0/go.mod h1:SkgaXwT+lIIAKqWAJfktHT/RbgjSuY6DobxEp0C5yTQ=
+cloud.google.com/go/videointelligence v1.10.0/go.mod h1:LHZngX1liVtUhZvi2uNS0VQuOzNi2TkY1OakiuoUOjU=
+cloud.google.com/go/vision/v2 v2.7.0/go.mod h1:H89VysHy21avemp6xcf9b9JvZHVehWbET0uT/bcuY/0=
+cloud.google.com/go/vmmigration v1.6.0/go.mod h1:bopQ/g4z+8qXzichC7GW1w2MjbErL54rk3/C843CjfY=
+cloud.google.com/go/vmwareengine v0.3.0/go.mod h1:wvoyMvNWdIzxMYSpH/R7y2h5h3WFkx6d+1TIsP39WGY=
+cloud.google.com/go/vpcaccess v1.6.0/go.mod h1:wX2ILaNhe7TlVa4vC5xce1bCnqE3AeH27RV31lnmZes=
+cloud.google.com/go/webrisk v1.8.0/go.mod h1:oJPDuamzHXgUc+b8SiHRcVInZQuybnvEW72PqTc7sSg=
+cloud.google.com/go/websecurityscanner v1.5.0/go.mod h1:Y6xdCPy81yi0SQnDY1xdNTNpfY1oAgXUlcfN3B3eSng=
+cloud.google.com/go/workflows v1.10.0/go.mod h1:fZ8LmRmZQWacon9UCX1r/g/DfAXx5VcPALq2CxzdePw=
+github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
+github.com/census-instrumentation/opencensus-proto v0.4.1/go.mod h1:4T9NM4+4Vw91VeyqjLS6ao50K5bOcLKN6Q42XnYaRYw=
+github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cncf/udpa/go v0.0.0-20220112060539-c52dc94e7fbe/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI=
+github.com/cncf/xds/go v0.0.0-20230607035331-e9ce68804cb4/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/envoyproxy/go-control-plane v0.11.1-0.20230524094728-9239064ad72f/go.mod h1:sfYdkwUW4BA3PbKjySwjJy+O4Pu0h62rlqCMHNk+K+Q=
+github.com/envoyproxy/protoc-gen-validate v0.10.1/go.mod h1:DRjgyB0I43LtJapqN6NiRwroiAU2PaFuvk/vjgh61ss=
+github.com/go-test/deep v1.0.2/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA=
+github.com/golang/glog v1.1.0/go.mod h1:pfYeQZ3JWZoXTV5sFc986z3HTpwQs9At6P4ImfuP3NQ=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
+github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
+github.com/hashicorp/consul/sdk v0.13.1/go.mod h1:SW/mM4LbKfqmMvcFu8v+eiQQ7oitXEFeiBe9StxERb0=
+github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-version v1.2.1/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/prometheus/client_golang v1.11.1/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
+github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
+github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+go.uber.org/automaxprocs v1.5.3/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0=
+go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/oauth2 v0.7.0/go.mod h1:hPLQkd9LyjfXTiRohC/41GhcFqxisoUQ99sCUOHO9x4=
+golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0=
+golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc=
diff --git a/vendor/github.com/knadh/koanf/v2/interfaces.go b/vendor/github.com/knadh/koanf/v2/interfaces.go
new file mode 100644
index 0000000000..ba69a2443a
--- /dev/null
+++ b/vendor/github.com/knadh/koanf/v2/interfaces.go
@@ -0,0 +1,20 @@
+package koanf
+
+// Provider represents a configuration provider. Providers can
+// read configuration from a source (file, HTTP etc.)
+type Provider interface {
+ // ReadBytes returns the entire configuration as raw []bytes to be parsed.
+ // with a Parser.
+ ReadBytes() ([]byte, error)
+
+ // Read returns the parsed configuration as a nested map[string]interface{}.
+ // It is important to note that the string keys should not be flat delimited
+ // keys like `parent.child.key`, but nested like `{parent: {child: {key: 1}}}`.
+ Read() (map[string]interface{}, error)
+}
+
+// Parser represents a configuration format parser.
+type Parser interface {
+ Unmarshal([]byte) (map[string]interface{}, error)
+ Marshal(map[string]interface{}) ([]byte, error)
+}
diff --git a/vendor/github.com/knadh/koanf/v2/koanf.go b/vendor/github.com/knadh/koanf/v2/koanf.go
new file mode 100644
index 0000000000..bd06a2d7e5
--- /dev/null
+++ b/vendor/github.com/knadh/koanf/v2/koanf.go
@@ -0,0 +1,577 @@
+package koanf
+
+import (
+ "bytes"
+ "encoding"
+ "fmt"
+ "reflect"
+ "sort"
+ "strconv"
+
+ "github.com/knadh/koanf/maps"
+ "github.com/mitchellh/copystructure"
+ "github.com/go-viper/mapstructure/v2"
+)
+
+// Koanf is the configuration apparatus.
+type Koanf struct {
+ confMap map[string]interface{}
+ confMapFlat map[string]interface{}
+ keyMap KeyMap
+ conf Conf
+}
+
+// Conf is the Koanf configuration.
+type Conf struct {
+ // Delim is the delimiter to use
+ // when specifying config key paths, for instance a . for `parent.child.key`
+ // or a / for `parent/child/key`.
+ Delim string
+
+ // StrictMerge makes the merging behavior strict.
+ // Meaning when loading two files that have the same key,
+ // the first loaded file will define the desired type, and if the second file loads
+ // a different type will cause an error.
+ StrictMerge bool
+}
+
+// KeyMap represents a map of flattened delimited keys and the non-delimited
+// parts as their slices. For nested keys, the map holds all levels of path combinations.
+// For example, the nested structure `parent -> child -> key` will produce the map:
+// parent.child.key => [parent, child, key]
+// parent.child => [parent, child]
+// parent => [parent]
+type KeyMap map[string][]string
+
+// UnmarshalConf represents configuration options used by
+// Unmarshal() to unmarshal conf maps into arbitrary structs.
+type UnmarshalConf struct {
+ // Tag is the struct field tag to unmarshal.
+ // `koanf` is used if left empty.
+ Tag string
+
+ // If this is set to true, instead of unmarshalling nested structures
+ // based on the key path, keys are taken literally to unmarshal into
+ // a flat struct. For example:
+ // ```
+ // type MyStuff struct {
+ // Child1Name string `koanf:"parent1.child1.name"`
+ // Child2Name string `koanf:"parent2.child2.name"`
+ // Type string `koanf:"json"`
+ // }
+ // ```
+ FlatPaths bool
+ DecoderConfig *mapstructure.DecoderConfig
+}
+
+// New returns a new instance of Koanf. delim is the delimiter to use
+// when specifying config key paths, for instance a . for `parent.child.key`
+// or a / for `parent/child/key`.
+func New(delim string) *Koanf {
+ return NewWithConf(Conf{
+ Delim: delim,
+ StrictMerge: false,
+ })
+}
+
+// NewWithConf returns a new instance of Koanf based on the Conf.
+func NewWithConf(conf Conf) *Koanf {
+ return &Koanf{
+ confMap: make(map[string]interface{}),
+ confMapFlat: make(map[string]interface{}),
+ keyMap: make(KeyMap),
+ conf: conf,
+ }
+}
+
+// Load takes a Provider that either provides a parsed config map[string]interface{}
+// in which case pa (Parser) can be nil, or raw bytes to be parsed, where a Parser
+// can be provided to parse. Additionally, options can be passed which modify the
+// load behavior, such as passing a custom merge function.
+func (ko *Koanf) Load(p Provider, pa Parser, opts ...Option) error {
+ var (
+ mp map[string]interface{}
+ err error
+ )
+
+ if p == nil {
+ return fmt.Errorf("load received a nil provider")
+ }
+
+ // No Parser is given. Call the Provider's Read() method to get
+ // the config map.
+ if pa == nil {
+ mp, err = p.Read()
+ if err != nil {
+ return err
+ }
+ } else {
+ // There's a Parser. Get raw bytes from the Provider to parse.
+ b, err := p.ReadBytes()
+ if err != nil {
+ return err
+ }
+ mp, err = pa.Unmarshal(b)
+ if err != nil {
+ return err
+ }
+ }
+
+ return ko.merge(mp, newOptions(opts))
+}
+
+// Keys returns the slice of all flattened keys in the loaded configuration
+// sorted alphabetically.
+func (ko *Koanf) Keys() []string {
+ out := make([]string, 0, len(ko.confMapFlat))
+ for k := range ko.confMapFlat {
+ out = append(out, k)
+ }
+ sort.Strings(out)
+ return out
+}
+
+// KeyMap returns a map of flattened keys and the individual parts of the
+// key as slices. eg: "parent.child.key" => ["parent", "child", "key"].
+func (ko *Koanf) KeyMap() KeyMap {
+ out := make(KeyMap, len(ko.keyMap))
+ for key, parts := range ko.keyMap {
+ out[key] = make([]string, len(parts))
+ copy(out[key], parts)
+ }
+ return out
+}
+
+// All returns a map of all flattened key paths and their values.
+// Note that it uses maps.Copy to create a copy that uses
+// json.Marshal which changes the numeric types to float64.
+func (ko *Koanf) All() map[string]interface{} {
+ return maps.Copy(ko.confMapFlat)
+}
+
+// Raw returns a copy of the full raw conf map.
+// Note that it uses maps.Copy to create a copy that uses
+// json.Marshal which changes the numeric types to float64.
+func (ko *Koanf) Raw() map[string]interface{} {
+ return maps.Copy(ko.confMap)
+}
+
+// Sprint returns a key -> value string representation
+// of the config map with keys sorted alphabetically.
+func (ko *Koanf) Sprint() string {
+ b := bytes.Buffer{}
+ for _, k := range ko.Keys() {
+ b.WriteString(fmt.Sprintf("%s -> %v\n", k, ko.confMapFlat[k]))
+ }
+ return b.String()
+}
+
+// Print prints a key -> value string representation
+// of the config map with keys sorted alphabetically.
+func (ko *Koanf) Print() {
+ fmt.Print(ko.Sprint())
+}
+
+// Cut cuts the config map at a given key path into a sub map and
+// returns a new Koanf instance with the cut config map loaded.
+// For instance, if the loaded config has a path that looks like
+// parent.child.sub.a.b, `Cut("parent.child")` returns a new Koanf
+// instance with the config map `sub.a.b` where everything above
+// `parent.child` are cut out.
+func (ko *Koanf) Cut(path string) *Koanf {
+ out := make(map[string]interface{})
+
+ // Cut only makes sense if the requested key path is a map.
+ if v, ok := ko.Get(path).(map[string]interface{}); ok {
+ out = v
+ }
+
+ n := New(ko.conf.Delim)
+ _ = n.merge(out, new(options))
+ return n
+}
+
+// Copy returns a copy of the Koanf instance.
+func (ko *Koanf) Copy() *Koanf {
+ return ko.Cut("")
+}
+
+// Merge merges the config map of a given Koanf instance into
+// the current instance.
+func (ko *Koanf) Merge(in *Koanf) error {
+ return ko.merge(in.Raw(), new(options))
+}
+
+// MergeAt merges the config map of a given Koanf instance into
+// the current instance as a sub map, at the given key path.
+// If all or part of the key path is missing, it will be created.
+// If the key path is `""`, this is equivalent to Merge.
+func (ko *Koanf) MergeAt(in *Koanf, path string) error {
+ // No path. Merge the two config maps.
+ if path == "" {
+ return ko.Merge(in)
+ }
+
+ // Unflatten the config map with the given key path.
+ n := maps.Unflatten(map[string]interface{}{
+ path: in.Raw(),
+ }, ko.conf.Delim)
+
+ return ko.merge(n, new(options))
+}
+
+// Set sets the value at a specific key.
+func (ko *Koanf) Set(key string, val interface{}) error {
+ // Unflatten the config map with the given key path.
+ n := maps.Unflatten(map[string]interface{}{
+ key: val,
+ }, ko.conf.Delim)
+
+ return ko.merge(n, new(options))
+}
+
+// Marshal takes a Parser implementation and marshals the config map into bytes,
+// for example, to TOML or JSON bytes.
+func (ko *Koanf) Marshal(p Parser) ([]byte, error) {
+ return p.Marshal(ko.Raw())
+}
+
+// Unmarshal unmarshals a given key path into the given struct using
+// the mapstructure lib. If no path is specified, the whole map is unmarshalled.
+// `koanf` is the struct field tag used to match field names. To customize,
+// use UnmarshalWithConf(). It uses the mitchellh/mapstructure package.
+func (ko *Koanf) Unmarshal(path string, o interface{}) error {
+ return ko.UnmarshalWithConf(path, o, UnmarshalConf{})
+}
+
+// UnmarshalWithConf is like Unmarshal but takes configuration params in UnmarshalConf.
+// See mitchellh/mapstructure's DecoderConfig for advanced customization
+// of the unmarshal behaviour.
+func (ko *Koanf) UnmarshalWithConf(path string, o interface{}, c UnmarshalConf) error {
+ if c.DecoderConfig == nil {
+ c.DecoderConfig = &mapstructure.DecoderConfig{
+ DecodeHook: mapstructure.ComposeDecodeHookFunc(
+ mapstructure.StringToTimeDurationHookFunc(),
+ textUnmarshalerHookFunc()),
+ Metadata: nil,
+ Result: o,
+ WeaklyTypedInput: true,
+ }
+ }
+
+ if c.Tag == "" {
+ c.DecoderConfig.TagName = "koanf"
+ } else {
+ c.DecoderConfig.TagName = c.Tag
+ }
+
+ d, err := mapstructure.NewDecoder(c.DecoderConfig)
+ if err != nil {
+ return err
+ }
+
+ // Unmarshal using flat key paths.
+ mp := ko.Get(path)
+ if c.FlatPaths {
+ if f, ok := mp.(map[string]interface{}); ok {
+ fmp, _ := maps.Flatten(f, nil, ko.conf.Delim)
+ mp = fmp
+ }
+ }
+
+ return d.Decode(mp)
+}
+
+// Delete removes all nested values from a given path.
+// Clears all keys/values if no path is specified.
+// Every empty, key on the path, is recursively deleted.
+func (ko *Koanf) Delete(path string) {
+ // No path. Erase the entire map.
+ if path == "" {
+ ko.confMap = make(map[string]interface{})
+ ko.confMapFlat = make(map[string]interface{})
+ ko.keyMap = make(KeyMap)
+ return
+ }
+
+ // Does the path exist?
+ p, ok := ko.keyMap[path]
+ if !ok {
+ return
+ }
+ maps.Delete(ko.confMap, p)
+
+ // Update the flattened version as well.
+ ko.confMapFlat, ko.keyMap = maps.Flatten(ko.confMap, nil, ko.conf.Delim)
+ ko.keyMap = populateKeyParts(ko.keyMap, ko.conf.Delim)
+}
+
+// Get returns the raw, uncast interface{} value of a given key path
+// in the config map. If the key path does not exist, nil is returned.
+func (ko *Koanf) Get(path string) interface{} {
+ // No path. Return the whole conf map.
+ if path == "" {
+ return ko.Raw()
+ }
+
+ // Does the path exist?
+ p, ok := ko.keyMap[path]
+ if !ok {
+ return nil
+ }
+ res := maps.Search(ko.confMap, p)
+
+ // Non-reference types are okay to return directly.
+ // Other types are "copied" with maps.Copy or json.Marshal
+ // that change the numeric types to float64.
+
+ switch v := res.(type) {
+ case int, int8, int16, int32, int64, float32, float64, string, bool:
+ return v
+ case map[string]interface{}:
+ return maps.Copy(v)
+ }
+
+ out, _ := copystructure.Copy(&res)
+ if ptrOut, ok := out.(*interface{}); ok {
+ return *ptrOut
+ }
+ return out
+}
+
+// Slices returns a list of Koanf instances constructed out of a
+// []map[string]interface{} interface at the given path.
+func (ko *Koanf) Slices(path string) []*Koanf {
+ out := []*Koanf{}
+ if path == "" {
+ return out
+ }
+
+ // Does the path exist?
+ sl, ok := ko.Get(path).([]interface{})
+ if !ok {
+ return out
+ }
+
+ for _, s := range sl {
+ mp, ok := s.(map[string]interface{})
+ if !ok {
+ continue
+ }
+
+ k := New(ko.conf.Delim)
+ _ = k.merge(mp, new(options))
+ out = append(out, k)
+ }
+
+ return out
+}
+
+// Exists returns true if the given key path exists in the conf map.
+func (ko *Koanf) Exists(path string) bool {
+ _, ok := ko.keyMap[path]
+ return ok
+}
+
+// MapKeys returns a sorted string list of keys in a map addressed by the
+// given path. If the path is not a map, an empty string slice is
+// returned.
+func (ko *Koanf) MapKeys(path string) []string {
+ var (
+ out = []string{}
+ o = ko.Get(path)
+ )
+ if o == nil {
+ return out
+ }
+
+ mp, ok := o.(map[string]interface{})
+ if !ok {
+ return out
+ }
+ out = make([]string, 0, len(mp))
+ for k := range mp {
+ out = append(out, k)
+ }
+ sort.Strings(out)
+ return out
+}
+
+// Delim returns delimiter in used by this instance of Koanf.
+func (ko *Koanf) Delim() string {
+ return ko.conf.Delim
+}
+
+func (ko *Koanf) merge(c map[string]interface{}, opts *options) error {
+ maps.IntfaceKeysToStrings(c)
+ if opts.merge != nil {
+ if err := opts.merge(c, ko.confMap); err != nil {
+ return err
+ }
+ } else if ko.conf.StrictMerge {
+ if err := maps.MergeStrict(c, ko.confMap); err != nil {
+ return err
+ }
+ } else {
+ maps.Merge(c, ko.confMap)
+ }
+
+ // Maintain a flattened version as well.
+ ko.confMapFlat, ko.keyMap = maps.Flatten(ko.confMap, nil, ko.conf.Delim)
+ ko.keyMap = populateKeyParts(ko.keyMap, ko.conf.Delim)
+
+ return nil
+}
+
+// toInt64 takes an interface value and if it is an integer type,
+// converts and returns int64. If it's any other type,
+// forces it to a string and attempts to do a strconv.Atoi
+// to get an integer out.
+func toInt64(v interface{}) (int64, error) {
+ switch i := v.(type) {
+ case int:
+ return int64(i), nil
+ case int8:
+ return int64(i), nil
+ case int16:
+ return int64(i), nil
+ case int32:
+ return int64(i), nil
+ case int64:
+ return i, nil
+ }
+
+ // Force it to a string and try to convert.
+ f, err := strconv.ParseFloat(fmt.Sprintf("%v", v), 64)
+ if err != nil {
+ return 0, err
+ }
+
+ return int64(f), nil
+}
+
+// toInt64 takes a `v interface{}` value and if it is a float type,
+// converts and returns a `float64`. If it's any other type, forces it to a
+// string and attempts to get a float out using `strconv.ParseFloat`.
+func toFloat64(v interface{}) (float64, error) {
+ switch i := v.(type) {
+ case float32:
+ return float64(i), nil
+ case float64:
+ return i, nil
+ }
+
+ // Force it to a string and try to convert.
+ f, err := strconv.ParseFloat(fmt.Sprintf("%v", v), 64)
+ if err != nil {
+ return f, err
+ }
+
+ return f, nil
+}
+
+// toBool takes an interface value and if it is a bool type,
+// returns it. If it's any other type, forces it to a string and attempts
+// to parse it as a bool using strconv.ParseBool.
+func toBool(v interface{}) (bool, error) {
+ if b, ok := v.(bool); ok {
+ return b, nil
+ }
+
+ // Force it to a string and try to convert.
+ b, err := strconv.ParseBool(fmt.Sprintf("%v", v))
+ if err != nil {
+ return b, err
+ }
+ return b, nil
+}
+
+// populateKeyParts iterates a key map and generates all possible
+// traversal paths. For instance, `parent.child.key` generates
+// `parent`, and `parent.child`.
+func populateKeyParts(m KeyMap, delim string) KeyMap {
+ out := make(KeyMap, len(m)) // The size of the result is at very least same to KeyMap
+ for _, parts := range m {
+ // parts is a slice of [parent, child, key]
+ var nk string
+
+ for i := range parts {
+ if i == 0 {
+ // On first iteration only use first part
+ nk = parts[i]
+ } else {
+ // If nk already contains a part (e.g. `parent`) append delim + `child`
+ nk += delim + parts[i]
+ }
+ if _, ok := out[nk]; ok {
+ continue
+ }
+ out[nk] = make([]string, i+1)
+ copy(out[nk], parts[0:i+1])
+ }
+ }
+ return out
+}
+
+// textUnmarshalerHookFunc is a fixed version of mapstructure.TextUnmarshallerHookFunc.
+// This hook allows to additionally unmarshal text into custom string types that implement the encoding.Text(Un)Marshaler interface(s).
+func textUnmarshalerHookFunc() mapstructure.DecodeHookFuncType {
+ return func(
+ f reflect.Type,
+ t reflect.Type,
+ data interface{},
+ ) (interface{}, error) {
+ if f.Kind() != reflect.String {
+ return data, nil
+ }
+ result := reflect.New(t).Interface()
+ unmarshaller, ok := result.(encoding.TextUnmarshaler)
+ if !ok {
+ return data, nil
+ }
+
+ // default text representation is the actual value of the `from` string
+ var (
+ dataVal = reflect.ValueOf(data)
+ text = []byte(dataVal.String())
+ )
+ if f.Kind() == t.Kind() {
+ // source and target are of underlying type string
+ var (
+ err error
+ ptrVal = reflect.New(dataVal.Type())
+ )
+ if !ptrVal.Elem().CanSet() {
+ // cannot set, skip, this should not happen
+ if err := unmarshaller.UnmarshalText(text); err != nil {
+ return nil, err
+ }
+ return result, nil
+ }
+ ptrVal.Elem().Set(dataVal)
+
+ // We need to assert that both, the value type and the pointer type
+ // do (not) implement the TextMarshaller interface before proceeding and simply
+ // using the string value of the string type.
+ // it might be the case that the internal string representation differs from
+ // the (un)marshalled string.
+
+ for _, v := range []reflect.Value{dataVal, ptrVal} {
+ if marshaller, ok := v.Interface().(encoding.TextMarshaler); ok {
+ text, err = marshaller.MarshalText()
+ if err != nil {
+ return nil, err
+ }
+ break
+ }
+ }
+ }
+
+ // text is either the source string's value or the source string type's marshaled value
+ // which may differ from its internal string value.
+ if err := unmarshaller.UnmarshalText(text); err != nil {
+ return nil, err
+ }
+ return result, nil
+ }
+}
diff --git a/vendor/github.com/knadh/koanf/v2/options.go b/vendor/github.com/knadh/koanf/v2/options.go
new file mode 100644
index 0000000000..63cea203e6
--- /dev/null
+++ b/vendor/github.com/knadh/koanf/v2/options.go
@@ -0,0 +1,33 @@
+package koanf
+
+// options contains options to modify the behavior of Koanf.Load.
+type options struct {
+ merge func(a, b map[string]interface{}) error
+}
+
+// newOptions creates a new options instance.
+func newOptions(opts []Option) *options {
+ o := new(options)
+ o.apply(opts)
+ return o
+}
+
+// Option is a generic type used to modify the behavior of Koanf.Load.
+type Option func(*options)
+
+// apply the given options.
+func (o *options) apply(opts []Option) {
+ for _, opt := range opts {
+ opt(o)
+ }
+}
+
+// WithMergeFunc is an option to modify the merge behavior of Koanf.Load.
+// If unset, the default merge function is used.
+//
+// The merge function is expected to merge map src into dest (left to right).
+func WithMergeFunc(merge func(src, dest map[string]interface{}) error) Option {
+ return func(o *options) {
+ o.merge = merge
+ }
+}
diff --git a/vendor/github.com/miekg/dns/README.md b/vendor/github.com/miekg/dns/README.md
index 9831c37baf..0e42858aed 100644
--- a/vendor/github.com/miekg/dns/README.md
+++ b/vendor/github.com/miekg/dns/README.md
@@ -86,7 +86,7 @@ A not-so-up-to-date-list-that-may-be-actually-current:
* https://linuxcontainers.org/incus/
* https://ifconfig.es
* https://github.com/zmap/zdns
-
+* https://framagit.org/bortzmeyer/check-soa
Send pull request if you want to be listed here.
@@ -193,6 +193,9 @@ Example programs can be found in the `github.com/miekg/exdns` repository.
* 9460 - Service Binding and Parameter Specification via the DNS
* 9461 - Service Binding Mapping for DNS Servers
* 9462 - Discovery of Designated Resolvers
+* 9460 - SVCB and HTTPS Records
+* 9606 - DNS Resolver Information
+* Draft - Compact Denial of Existence in DNSSEC
## Loosely Based Upon
diff --git a/vendor/github.com/miekg/dns/edns.go b/vendor/github.com/miekg/dns/edns.go
index 0447fd826a..91793b9069 100644
--- a/vendor/github.com/miekg/dns/edns.go
+++ b/vendor/github.com/miekg/dns/edns.go
@@ -27,6 +27,7 @@ const (
EDNS0LOCALSTART = 0xFDE9 // Beginning of range reserved for local/experimental use (See RFC 6891)
EDNS0LOCALEND = 0xFFFE // End of range reserved for local/experimental use (See RFC 6891)
_DO = 1 << 15 // DNSSEC OK
+ _CO = 1 << 14 // Compact Answers OK
)
// makeDataOpt is used to unpack the EDNS0 option(s) from a message.
@@ -75,7 +76,11 @@ type OPT struct {
func (rr *OPT) String() string {
s := "\n;; OPT PSEUDOSECTION:\n; EDNS: version " + strconv.Itoa(int(rr.Version())) + "; "
if rr.Do() {
- s += "flags: do; "
+ if rr.Co() {
+ s += "flags: do, co; "
+ } else {
+ s += "flags: do; "
+ }
} else {
s += "flags:; "
}
@@ -195,14 +200,34 @@ func (rr *OPT) SetDo(do ...bool) {
}
}
-// Z returns the Z part of the OPT RR as a uint16 with only the 15 least significant bits used.
+// Co returns the value of the CO (Compact Answers OK) bit.
+func (rr *OPT) Co() bool {
+ return rr.Hdr.Ttl&_CO == _CO
+}
+
+// SetCo sets the CO (Compact Answers OK) bit.
+// If we pass an argument, set the CO bit to that value.
+// It is possible to pass 2 or more arguments, but they will be ignored.
+func (rr *OPT) SetCo(co ...bool) {
+ if len(co) == 1 {
+ if co[0] {
+ rr.Hdr.Ttl |= _CO
+ } else {
+ rr.Hdr.Ttl &^= _CO
+ }
+ } else {
+ rr.Hdr.Ttl |= _CO
+ }
+}
+
+// Z returns the Z part of the OPT RR as a uint16 with only the 14 least significant bits used.
func (rr *OPT) Z() uint16 {
- return uint16(rr.Hdr.Ttl & 0x7FFF)
+ return uint16(rr.Hdr.Ttl & 0x3FFF)
}
-// SetZ sets the Z part of the OPT RR, note only the 15 least significant bits of z are used.
+// SetZ sets the Z part of the OPT RR, note only the 14 least significant bits of z are used.
func (rr *OPT) SetZ(z uint16) {
- rr.Hdr.Ttl = rr.Hdr.Ttl&^0x7FFF | uint32(z&0x7FFF)
+ rr.Hdr.Ttl = rr.Hdr.Ttl&^0x3FFF | uint32(z&0x3FFF)
}
// EDNS0 defines an EDNS0 Option. An OPT RR can have multiple options appended to it.
diff --git a/vendor/github.com/miekg/dns/scan.go b/vendor/github.com/miekg/dns/scan.go
index e26e8027a4..fa8a332eda 100644
--- a/vendor/github.com/miekg/dns/scan.go
+++ b/vendor/github.com/miekg/dns/scan.go
@@ -108,6 +108,8 @@ type ttlState struct {
// origin for resolving relative domain names defaults to the DNS root (.).
// Full zone file syntax is supported, including directives like $TTL and $ORIGIN.
// All fields of the returned RR are set from the read data, except RR.Header().Rdlength which is set to 0.
+// Is you need a partial resource record with no rdata - for instance - for dynamic updates, see the [ANY]
+// documentation.
func NewRR(s string) (RR, error) {
if len(s) > 0 && s[len(s)-1] != '\n' { // We need a closing newline
return ReadRR(strings.NewReader(s+"\n"), "")
diff --git a/vendor/github.com/miekg/dns/scan_rr.go b/vendor/github.com/miekg/dns/scan_rr.go
index c1a76995e7..ac885f66fe 100644
--- a/vendor/github.com/miekg/dns/scan_rr.go
+++ b/vendor/github.com/miekg/dns/scan_rr.go
@@ -1620,6 +1620,16 @@ func (rr *NINFO) parse(c *zlexer, o string) *ParseError {
return nil
}
+// Uses the same format as TXT
+func (rr *RESINFO) parse(c *zlexer, o string) *ParseError {
+ s, e := endingToTxtSlice(c, "bad RESINFO Resinfo")
+ if e != nil {
+ return e
+ }
+ rr.Txt = s
+ return nil
+}
+
func (rr *URI) parse(c *zlexer, o string) *ParseError {
l, _ := c.Next()
i, e := strconv.ParseUint(l.token, 10, 16)
diff --git a/vendor/github.com/miekg/dns/svcb.go b/vendor/github.com/miekg/dns/svcb.go
index 310c7d11f5..d1baeea992 100644
--- a/vendor/github.com/miekg/dns/svcb.go
+++ b/vendor/github.com/miekg/dns/svcb.go
@@ -214,11 +214,7 @@ func makeSVCBKeyValue(key SVCBKey) SVCBKeyValue {
}
}
-// SVCB RR. See RFC xxxx (https://tools.ietf.org/html/draft-ietf-dnsop-svcb-https-08).
-//
-// NOTE: The HTTPS/SVCB RFCs are in the draft stage.
-// The API, including constants and types related to SVCBKeyValues, may
-// change in future versions in accordance with the latest drafts.
+// SVCB RR. See RFC 9460.
type SVCB struct {
Hdr RR_Header
Priority uint16 // If zero, Value must be empty or discarded by the user of this library
@@ -226,12 +222,8 @@ type SVCB struct {
Value []SVCBKeyValue `dns:"pairs"`
}
-// HTTPS RR. Everything valid for SVCB applies to HTTPS as well.
+// HTTPS RR. See RFC 9460. Everything valid for SVCB applies to HTTPS as well.
// Except that the HTTPS record is intended for use with the HTTP and HTTPS protocols.
-//
-// NOTE: The HTTPS/SVCB RFCs are in the draft stage.
-// The API, including constants and types related to SVCBKeyValues, may
-// change in future versions in accordance with the latest drafts.
type HTTPS struct {
SVCB
}
diff --git a/vendor/github.com/miekg/dns/types.go b/vendor/github.com/miekg/dns/types.go
index 7a34c14ca0..e39cf2fecf 100644
--- a/vendor/github.com/miekg/dns/types.go
+++ b/vendor/github.com/miekg/dns/types.go
@@ -101,6 +101,7 @@ const (
TypeCAA uint16 = 257
TypeAVC uint16 = 258
TypeAMTRELAY uint16 = 260
+ TypeRESINFO uint16 = 261
TypeTKEY uint16 = 249
TypeTSIG uint16 = 250
@@ -267,11 +268,20 @@ func (q *Question) String() (s string) {
return s
}
-// ANY is a wild card record. See RFC 1035, Section 3.2.3. ANY
-// is named "*" there.
+// ANY is a wild card record. See RFC 1035, Section 3.2.3. ANY is named "*" there.
+// The ANY records can be (ab)used to create resource records without any rdata, that
+// can be used in dynamic update requests. Basic use pattern:
+//
+// a := &ANY{RR_Header{
+// Name: "example.org.",
+// Rrtype: TypeA,
+// Class: ClassINET,
+// }}
+//
+// Results in an A record without rdata.
type ANY struct {
Hdr RR_Header
- // Does not have any rdata
+ // Does not have any rdata.
}
func (rr *ANY) String() string { return rr.Hdr.String() }
@@ -1508,6 +1518,15 @@ func (rr *ZONEMD) String() string {
" " + rr.Digest
}
+// RESINFO RR. See RFC 9606.
+
+type RESINFO struct {
+ Hdr RR_Header
+ Txt []string `dns:"txt"`
+}
+
+func (rr *RESINFO) String() string { return rr.Hdr.String() + sprintTxt(rr.Txt) }
+
// APL RR. See RFC 3123.
type APL struct {
Hdr RR_Header
diff --git a/vendor/github.com/miekg/dns/udp.go b/vendor/github.com/miekg/dns/udp.go
index c018ad43da..d226718595 100644
--- a/vendor/github.com/miekg/dns/udp.go
+++ b/vendor/github.com/miekg/dns/udp.go
@@ -1,5 +1,5 @@
-//go:build !windows
-// +build !windows
+//go:build !windows && !darwin
+// +build !windows,!darwin
package dns
diff --git a/vendor/github.com/miekg/dns/udp_windows.go b/vendor/github.com/miekg/dns/udp_no_control.go
similarity index 85%
rename from vendor/github.com/miekg/dns/udp_windows.go
rename to vendor/github.com/miekg/dns/udp_no_control.go
index a259b67e4d..ca3d4a633b 100644
--- a/vendor/github.com/miekg/dns/udp_windows.go
+++ b/vendor/github.com/miekg/dns/udp_no_control.go
@@ -1,9 +1,11 @@
-//go:build windows
-// +build windows
+//go:build windows || darwin
+// +build windows darwin
// TODO(tmthrgd): Remove this Windows-specific code if go.dev/issue/7175 and
// go.dev/issue/7174 are ever fixed.
+// NOTICE(stek29): darwin supports PKTINFO in sendmsg, but it unbinds sockets, see https://github.com/miekg/dns/issues/724
+
package dns
import "net"
diff --git a/vendor/github.com/miekg/dns/update.go b/vendor/github.com/miekg/dns/update.go
index 16f9ee85a5..2fef1461f5 100644
--- a/vendor/github.com/miekg/dns/update.go
+++ b/vendor/github.com/miekg/dns/update.go
@@ -2,6 +2,7 @@ package dns
// NameUsed sets the RRs in the prereq section to
// "Name is in use" RRs. RFC 2136 section 2.4.4.
+// See [ANY] on how to make RRs without rdata.
func (u *Msg) NameUsed(rr []RR) {
if u.Answer == nil {
u.Answer = make([]RR, 0, len(rr))
@@ -41,6 +42,7 @@ func (u *Msg) Used(rr []RR) {
// RRsetUsed sets the RRs in the prereq section to
// "RRset exists (value independent -- no rdata)" RRs. RFC 2136 section 2.4.1.
+// See [ANY] on how to make RRs without rdata.
func (u *Msg) RRsetUsed(rr []RR) {
if u.Answer == nil {
u.Answer = make([]RR, 0, len(rr))
@@ -53,6 +55,7 @@ func (u *Msg) RRsetUsed(rr []RR) {
// RRsetNotUsed sets the RRs in the prereq section to
// "RRset does not exist" RRs. RFC 2136 section 2.4.3.
+// See [ANY] on how to make RRs without rdata.
func (u *Msg) RRsetNotUsed(rr []RR) {
if u.Answer == nil {
u.Answer = make([]RR, 0, len(rr))
@@ -64,6 +67,7 @@ func (u *Msg) RRsetNotUsed(rr []RR) {
}
// Insert creates a dynamic update packet that adds an complete RRset, see RFC 2136 section 2.5.1.
+// See [ANY] on how to make RRs without rdata.
func (u *Msg) Insert(rr []RR) {
if len(u.Question) == 0 {
panic("dns: empty question section")
@@ -78,6 +82,7 @@ func (u *Msg) Insert(rr []RR) {
}
// RemoveRRset creates a dynamic update packet that deletes an RRset, see RFC 2136 section 2.5.2.
+// See [ANY] on how to make RRs without rdata.
func (u *Msg) RemoveRRset(rr []RR) {
if u.Ns == nil {
u.Ns = make([]RR, 0, len(rr))
@@ -89,6 +94,7 @@ func (u *Msg) RemoveRRset(rr []RR) {
}
// RemoveName creates a dynamic update packet that deletes all RRsets of a name, see RFC 2136 section 2.5.3
+// See [ANY] on how to make RRs without rdata.
func (u *Msg) RemoveName(rr []RR) {
if u.Ns == nil {
u.Ns = make([]RR, 0, len(rr))
@@ -99,6 +105,7 @@ func (u *Msg) RemoveName(rr []RR) {
}
// Remove creates a dynamic update packet deletes RR from a RRSset, see RFC 2136 section 2.5.4
+// See [ANY] on how to make RRs without rdata.
func (u *Msg) Remove(rr []RR) {
if u.Ns == nil {
u.Ns = make([]RR, 0, len(rr))
diff --git a/vendor/github.com/miekg/dns/version.go b/vendor/github.com/miekg/dns/version.go
index e290e3dff7..73e34edc31 100644
--- a/vendor/github.com/miekg/dns/version.go
+++ b/vendor/github.com/miekg/dns/version.go
@@ -3,7 +3,7 @@ package dns
import "fmt"
// Version is current version of this library.
-var Version = v{1, 1, 63}
+var Version = v{1, 1, 65}
// v holds the version of this library.
type v struct {
diff --git a/vendor/github.com/miekg/dns/zduplicate.go b/vendor/github.com/miekg/dns/zduplicate.go
index 330c05395f..ebd9e02970 100644
--- a/vendor/github.com/miekg/dns/zduplicate.go
+++ b/vendor/github.com/miekg/dns/zduplicate.go
@@ -957,6 +957,23 @@ func (r1 *PX) isDuplicate(_r2 RR) bool {
return true
}
+func (r1 *RESINFO) isDuplicate(_r2 RR) bool {
+ r2, ok := _r2.(*RESINFO)
+ if !ok {
+ return false
+ }
+ _ = r2
+ if len(r1.Txt) != len(r2.Txt) {
+ return false
+ }
+ for i := 0; i < len(r1.Txt); i++ {
+ if r1.Txt[i] != r2.Txt[i] {
+ return false
+ }
+ }
+ return true
+}
+
func (r1 *RFC3597) isDuplicate(_r2 RR) bool {
r2, ok := _r2.(*RFC3597)
if !ok {
diff --git a/vendor/github.com/miekg/dns/zmsg.go b/vendor/github.com/miekg/dns/zmsg.go
index 5a6cf4c6ad..cc09810fb1 100644
--- a/vendor/github.com/miekg/dns/zmsg.go
+++ b/vendor/github.com/miekg/dns/zmsg.go
@@ -762,6 +762,14 @@ func (rr *PX) pack(msg []byte, off int, compression compressionMap, compress boo
return off, nil
}
+func (rr *RESINFO) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
+ off, err = packStringTxt(rr.Txt, msg, off)
+ if err != nil {
+ return off, err
+ }
+ return off, nil
+}
+
func (rr *RFC3597) pack(msg []byte, off int, compression compressionMap, compress bool) (off1 int, err error) {
off, err = packStringHex(rr.Rdata, msg, off)
if err != nil {
@@ -2353,6 +2361,17 @@ func (rr *PX) unpack(msg []byte, off int) (off1 int, err error) {
return off, nil
}
+func (rr *RESINFO) unpack(msg []byte, off int) (off1 int, err error) {
+ rdStart := off
+ _ = rdStart
+
+ rr.Txt, off, err = unpackStringTxt(msg, off)
+ if err != nil {
+ return off, err
+ }
+ return off, nil
+}
+
func (rr *RFC3597) unpack(msg []byte, off int) (off1 int, err error) {
rdStart := off
_ = rdStart
diff --git a/vendor/github.com/miekg/dns/ztypes.go b/vendor/github.com/miekg/dns/ztypes.go
index 11f13ecf9c..cea79ae772 100644
--- a/vendor/github.com/miekg/dns/ztypes.go
+++ b/vendor/github.com/miekg/dns/ztypes.go
@@ -66,6 +66,7 @@ var TypeToRR = map[uint16]func() RR{
TypeOPT: func() RR { return new(OPT) },
TypePTR: func() RR { return new(PTR) },
TypePX: func() RR { return new(PX) },
+ TypeRESINFO: func() RR { return new(RESINFO) },
TypeRKEY: func() RR { return new(RKEY) },
TypeRP: func() RR { return new(RP) },
TypeRRSIG: func() RR { return new(RRSIG) },
@@ -154,6 +155,7 @@ var TypeToString = map[uint16]string{
TypeOPT: "OPT",
TypePTR: "PTR",
TypePX: "PX",
+ TypeRESINFO: "RESINFO",
TypeRKEY: "RKEY",
TypeRP: "RP",
TypeRRSIG: "RRSIG",
@@ -238,6 +240,7 @@ func (rr *OPENPGPKEY) Header() *RR_Header { return &rr.Hdr }
func (rr *OPT) Header() *RR_Header { return &rr.Hdr }
func (rr *PTR) Header() *RR_Header { return &rr.Hdr }
func (rr *PX) Header() *RR_Header { return &rr.Hdr }
+func (rr *RESINFO) Header() *RR_Header { return &rr.Hdr }
func (rr *RFC3597) Header() *RR_Header { return &rr.Hdr }
func (rr *RKEY) Header() *RR_Header { return &rr.Hdr }
func (rr *RP) Header() *RR_Header { return &rr.Hdr }
@@ -622,6 +625,14 @@ func (rr *PX) len(off int, compression map[string]struct{}) int {
return l
}
+func (rr *RESINFO) len(off int, compression map[string]struct{}) int {
+ l := rr.Hdr.len(off, compression)
+ for _, x := range rr.Txt {
+ l += len(x) + 1
+ }
+ return l
+}
+
func (rr *RFC3597) len(off int, compression map[string]struct{}) int {
l := rr.Hdr.len(off, compression)
l += len(rr.Rdata) / 2
@@ -1148,6 +1159,10 @@ func (rr *PX) copy() RR {
}
}
+func (rr *RESINFO) copy() RR {
+ return &RESINFO{rr.Hdr, cloneSlice(rr.Txt)}
+}
+
func (rr *RFC3597) copy() RR {
return &RFC3597{rr.Hdr, rr.Rdata}
}
diff --git a/vendor/github.com/oklog/ulid/v2/.gitignore b/vendor/github.com/oklog/ulid/v2/.gitignore
new file mode 100644
index 0000000000..c92c4d5608
--- /dev/null
+++ b/vendor/github.com/oklog/ulid/v2/.gitignore
@@ -0,0 +1,29 @@
+#### joe made this: http://goel.io/joe
+
+#####=== Go ===#####
+
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
+
diff --git a/vendor/github.com/oklog/ulid/v2/AUTHORS.md b/vendor/github.com/oklog/ulid/v2/AUTHORS.md
new file mode 100644
index 0000000000..95581c78b0
--- /dev/null
+++ b/vendor/github.com/oklog/ulid/v2/AUTHORS.md
@@ -0,0 +1,2 @@
+- Peter Bourgon (@peterbourgon)
+- Tomás Senart (@tsenart)
diff --git a/vendor/github.com/oklog/ulid/v2/CHANGELOG.md b/vendor/github.com/oklog/ulid/v2/CHANGELOG.md
new file mode 100644
index 0000000000..8da38c6b00
--- /dev/null
+++ b/vendor/github.com/oklog/ulid/v2/CHANGELOG.md
@@ -0,0 +1,33 @@
+## 1.3.1 / 2018-10-02
+
+* Use underlying entropy source for random increments in Monotonic (#32)
+
+## 1.3.0 / 2018-09-29
+
+* Monotonic entropy support (#31)
+
+## 1.2.0 / 2018-09-09
+
+* Add a function to convert Unix time in milliseconds back to time.Time (#30)
+
+## 1.1.0 / 2018-08-15
+
+* Ensure random part is always read from the entropy reader in full (#28)
+
+## 1.0.0 / 2018-07-29
+
+* Add ParseStrict and MustParseStrict functions (#26)
+* Enforce overflow checking when parsing (#20)
+
+## 0.3.0 / 2017-01-03
+
+* Implement ULID.Compare method
+
+## 0.2.0 / 2016-12-13
+
+* Remove year 2262 Timestamp bug. (#1)
+* Gracefully handle invalid encodings when parsing.
+
+## 0.1.0 / 2016-12-06
+
+* First ULID release
diff --git a/vendor/github.com/oklog/ulid/v2/CONTRIBUTING.md b/vendor/github.com/oklog/ulid/v2/CONTRIBUTING.md
new file mode 100644
index 0000000000..68f03f26eb
--- /dev/null
+++ b/vendor/github.com/oklog/ulid/v2/CONTRIBUTING.md
@@ -0,0 +1,17 @@
+# Contributing
+
+We use GitHub to manage reviews of pull requests.
+
+* If you have a trivial fix or improvement, go ahead and create a pull
+ request, addressing (with `@...`) one or more of the maintainers
+ (see [AUTHORS.md](AUTHORS.md)) in the description of the pull request.
+
+* If you plan to do something more involved, first propose your ideas
+ in a Github issue. This will avoid unnecessary work and surely give
+ you and us a good deal of inspiration.
+
+* Relevant coding style guidelines are the [Go Code Review
+ Comments](https://code.google.com/p/go-wiki/wiki/CodeReviewComments)
+ and the _Formatting and style_ section of Peter Bourgon's [Go: Best
+ Practices for Production
+ Environments](http://peter.bourgon.org/go-in-production/#formatting-and-style).
diff --git a/vendor/github.com/oklog/ulid/v2/LICENSE b/vendor/github.com/oklog/ulid/v2/LICENSE
new file mode 100644
index 0000000000..261eeb9e9f
--- /dev/null
+++ b/vendor/github.com/oklog/ulid/v2/LICENSE
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ 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.
diff --git a/vendor/github.com/oklog/ulid/v2/README.md b/vendor/github.com/oklog/ulid/v2/README.md
new file mode 100644
index 0000000000..c0094ce881
--- /dev/null
+++ b/vendor/github.com/oklog/ulid/v2/README.md
@@ -0,0 +1,234 @@
+# Universally Unique Lexicographically Sortable Identifier
+
+[](https://github.com/oklog/ulid/releases/latest)
+
+[](https://goreportcard.com/report/oklog/ulid)
+[](https://coveralls.io/github/oklog/ulid?branch=master)
+[](https://pkg.go.dev/github.com/oklog/ulid/v2)
+[](https://raw.githubusercontent.com/oklog/ulid/master/LICENSE)
+
+A Go port of [ulid/javascript](https://github.com/ulid/javascript) with binary format implemented.
+
+## Background
+
+A GUID/UUID can be suboptimal for many use-cases because:
+
+- It isn't the most character efficient way of encoding 128 bits
+- UUID v1/v2 is impractical in many environments, as it requires access to a unique, stable MAC address
+- UUID v3/v5 requires a unique seed and produces randomly distributed IDs, which can cause fragmentation in many data structures
+- UUID v4 provides no other information than randomness which can cause fragmentation in many data structures
+
+A ULID however:
+
+- Is compatible with UUID/GUID's
+- 1.21e+24 unique ULIDs per millisecond (1,208,925,819,614,629,174,706,176 to be exact)
+- Lexicographically sortable
+- Canonically encoded as a 26 character string, as opposed to the 36 character UUID
+- Uses Crockford's base32 for better efficiency and readability (5 bits per character)
+- Case insensitive
+- No special characters (URL safe)
+- Monotonic sort order (correctly detects and handles the same millisecond)
+
+## Install
+
+This package requires Go modules.
+
+```shell
+go get github.com/oklog/ulid/v2
+```
+
+## Usage
+
+ULIDs are constructed from two things: a timestamp with millisecond precision,
+and some random data.
+
+Timestamps are modeled as uint64 values representing a Unix time in milliseconds.
+They can be produced by passing a [time.Time](https://pkg.go.dev/time#Time) to
+[ulid.Timestamp](https://pkg.go.dev/github.com/oklog/ulid/v2#Timestamp),
+or by calling [time.Time.UnixMilli](https://pkg.go.dev/time#Time.UnixMilli)
+and converting the returned value to `uint64`.
+
+Random data is taken from a provided [io.Reader](https://pkg.go.dev/io#Reader).
+This design allows for greater flexibility when choosing trade-offs, but can be
+a bit confusing to newcomers.
+
+If you just want to generate a ULID and don't (yet) care about details like
+performance, cryptographic security, monotonicity, etc., use the
+[ulid.Make](https://pkg.go.dev/github.com/oklog/ulid/v2#Make) helper function.
+This function calls [time.Now](https://pkg.go.dev/time#Now) to get a timestamp,
+and uses a source of entropy which is process-global,
+[pseudo-random](https://pkg.go.dev/math/rand)), and
+[monotonic](https://pkg.go.dev/oklog/ulid/v2#LockedMonotonicReader)).
+
+```go
+println(ulid.Make())
+// 01G65Z755AFWAKHE12NY0CQ9FH
+```
+
+More advanced use cases should utilize
+[ulid.New](https://pkg.go.dev/github.com/oklog/ulid/v2#New).
+
+```go
+entropy := rand.New(rand.NewSource(time.Now().UnixNano()))
+ms := ulid.Timestamp(time.Now())
+println(ulid.New(ms, entropy))
+// 01G65Z755AFWAKHE12NY0CQ9FH
+```
+
+Care should be taken when providing a source of entropy.
+
+The above example utilizes [math/rand.Rand](https://pkg.go.dev/math/rand#Rand),
+which is not safe for concurrent use by multiple goroutines. Consider
+alternatives such as
+[x/exp/rand](https://pkg.go.dev/golang.org/x/exp/rand#LockedSource).
+Security-sensitive use cases should always use cryptographically secure entropy
+provided by [crypto/rand](https://pkg.go.dev/crypto/rand).
+
+Performance-sensitive use cases should avoid synchronization when generating
+IDs. One option is to use a unique source of entropy for each concurrent
+goroutine, which results in no lock contention, but cannot provide strong
+guarantees about the random data, and does not provide monotonicity within a
+given millisecond. One common performance optimization is to pool sources of
+entropy using a [sync.Pool](https://pkg.go.dev/sync#Pool).
+
+Monotonicity is a property that says each ULID is "bigger than" the previous
+one. ULIDs are automatically monotonic, but only to millisecond precision. ULIDs
+generated within the same millisecond are ordered by their random component,
+which means they are by default un-ordered. You can use
+[ulid.MonotonicEntropy](https://pkg.go.dev/oklog/ulid/v2#MonotonicEntropy) or
+[ulid.LockedMonotonicEntropy](https://pkg.go.dev/oklog/ulid/v2#LockedMonotonicEntropy)
+to create ULIDs that are monotonic within a given millisecond, with caveats. See
+the documentation for details.
+
+If you don't care about time-based ordering of generated IDs, then there's no
+reason to use ULIDs! There are many other kinds of IDs that are easier, faster,
+smaller, etc. Consider UUIDs.
+
+## Commandline tool
+
+This repo also provides a tool to generate and parse ULIDs at the command line.
+These commands should install the latest version of the tool at `bin/ulid`:
+
+```shell
+cd $(mktemp -d)
+env GOPATH=$(pwd) GO111MODULE=on go get -v github.com/oklog/ulid/v2/cmd/ulid
+```
+
+Usage:
+
+```shell
+Usage: ulid [-hlqz] [-f