| Command\n | \nDescription\n | \n
| FROM\n | \nUsed to unpack the initial (and subsequent base images for the mutli-step case).\n | \n
| RUN\n | \nThe command will be run, with shell prepending, and the FS snapshotted after each command.\n | \n
| CMD, ENTRYPOINT, LABEL, MAINTAINER, EXPOSE, VOLUME, STOPSIGNAL, HEALTHCHECK\n | \nMetadata-only operations.\n | \n
| ENV, WORKDIR, USER, SHELL\n | \nMostly metadata only - Variables must also be applied to the build environment at the proper time for use in subsequent RUN commands.\n | \n
| ADD/COPY\n | \nFiles will be copied out of the build context and into the build environment. For multi-step builds, filesu will be saved from the previous build environment so they can be copied into later steps.\n | \n
| ARG\n | \nARG variables will be supplied to the build executable and substituted in appropriately during parsing.\n | \n
![\"Donate](\"https://liberapay.com/assets/widgets/donate.svg\")
\n![\"Become](\"https://img.shields.io/github/sponsors/imdario?style=for-the-badge\")
\n\n### Mergo in the wild\n\nMergo is used by [thousands](https://deps.dev/go/dario.cat%2Fmergo/v1.0.0/dependents) [of](https://deps.dev/go/github.com%2Fimdario%2Fmergo/v0.3.16/dependents) [projects](https://deps.dev/go/github.com%2Fimdario%2Fmergo/v0.3.12), including:\n\n* [containerd/containerd](https://github.com/containerd/containerd)\n* [datadog/datadog-agent](https://github.com/datadog/datadog-agent)\n* [docker/cli/](https://github.com/docker/cli/)\n* [goreleaser/goreleaser](https://github.com/goreleaser/goreleaser)\n* [go-micro/go-micro](https://github.com/go-micro/go-micro)\n* [grafana/loki](https://github.com/grafana/loki)\n* [masterminds/sprig](github.com/Masterminds/sprig)\n* [moby/moby](https://github.com/moby/moby)\n* [slackhq/nebula](https://github.com/slackhq/nebula)\n* [volcano-sh/volcano](https://github.com/volcano-sh/volcano)\n\n## Install\n\n go get dario.cat/mergo\n\n // use in your .go code\n import (\n \"dario.cat/mergo\"\n )\n\n## Usage\n\nYou can only merge same-type structs with exported fields initialized as zero value of their type and same-types maps. Mergo won't merge unexported (private) fields but will do recursively any exported one. It won't merge empty structs value as [they are zero values](https://golang.org/ref/spec#The_zero_value) too. Also, maps will be merged recursively except for structs inside maps (because they are not addressable using Go reflection).\n\n```go\nif err := mergo.Merge(&dst, src); err != nil {\n // ...\n}\n```\n\nAlso, you can merge overwriting values using the transformer `WithOverride`.\n\n```go\nif err := mergo.Merge(&dst, src, mergo.WithOverride); err != nil {\n // ...\n}\n```\n\nIf you need to override pointers, so the source pointer's value is assigned to the destination's pointer, you must use `WithoutDereference`:\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"dario.cat/mergo\"\n)\n\ntype Foo struct {\n\tA *string\n\tB int64\n}\n\nfunc main() {\n\tfirst := \"first\"\n\tsecond := \"second\"\n\tsrc := Foo{\n\t\tA: &first,\n\t\tB: 2,\n\t}\n\n\tdest := Foo{\n\t\tA: &second,\n\t\tB: 1,\n\t}\n\n\tmergo.Merge(&dest, src, mergo.WithOverride, mergo.WithoutDereference)\n}\n```\n\nAdditionally, you can map a `map[string]interface{}` to a struct (and otherwise, from struct to map), following the same restrictions as in `Merge()`. Keys are capitalized to find each corresponding exported field.\n\n```go\nif err := mergo.Map(&dst, srcMap); err != nil {\n // ...\n}\n```\n\nWarning: if you map a struct to map, it won't do it recursively. Don't expect Mergo to map struct members of your struct as `map[string]interface{}`. They will be just assigned as values.\n\nHere is a nice example:\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"dario.cat/mergo\"\n)\n\ntype Foo struct {\n\tA string\n\tB int64\n}\n\nfunc main() {\n\tsrc := Foo{\n\t\tA: \"one\",\n\t\tB: 2,\n\t}\n\tdest := Foo{\n\t\tA: \"two\",\n\t}\n\tmergo.Merge(&dest, src)\n\tfmt.Println(dest)\n\t// Will print\n\t// {two 2}\n}\n```\n\n### Transformers\n\nTransformers allow to merge specific types differently than in the default behavior. In other words, now you can customize how some types are merged. For example, `time.Time` is a struct; it doesn't have zero value but IsZero can return true because it has fields with zero value. How can we merge a non-zero `time.Time`?\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"dario.cat/mergo\"\n \"reflect\"\n \"time\"\n)\n\ntype timeTransformer struct {\n}\n\nfunc (t timeTransformer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error {\n\tif typ == reflect.TypeOf(time.Time{}) {\n\t\treturn func(dst, src reflect.Value) error {\n\t\t\tif dst.CanSet() {\n\t\t\t\tisZero := dst.MethodByName(\"IsZero\")\n\t\t\t\tresult := isZero.Call([]reflect.Value{})\n\t\t\t\tif result[0].Bool() {\n\t\t\t\t\tdst.Set(src)\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn nil\n\t\t}\n\t}\n\treturn nil\n}\n\ntype Snapshot struct {\n\tTime time.Time\n\t// ...\n}\n\nfunc main() {\n\tsrc := Snapshot{time.Now()}\n\tdest := Snapshot{}\n\tmergo.Merge(&dest, src, mergo.WithTransformers(timeTransformer{}))\n\tfmt.Println(dest)\n\t// Will print\n\t// { 2018-01-12 01:15:00 +0000 UTC m=+0.000000001 }\n}\n```\n\n## Contact me\n\nIf I can help you, you have an idea or you are using Mergo in your projects, don't hesitate to drop me a line (or a pull request): [@im_dario](https://twitter.com/im_dario)\n\n## About\n\nWritten by [Dario Castaรฑรฉ](http://dario.im).\n\n## License\n\n[BSD 3-Clause](http://opensource.org/licenses/BSD-3-Clause) license, as [Go language](http://golang.org/LICENSE).\n\n[](https://app.fossa.io/projects/git%2Bgithub.com%2Fimdario%2Fmergo?ref=badge_large)\n"
},
{
"path": "vendor/dario.cat/mergo/SECURITY.md",
"content": "# Security Policy\n\n## Supported Versions\n\n| Version | Supported |\n| ------- | ------------------ |\n| 1.x.x | :white_check_mark: |\n| < 1.0 | :x: |\n\n## Security contact information\n\nTo report a security vulnerability, please use the\n[Tidelift security contact](https://tidelift.com/security).\nTidelift will coordinate the fix and disclosure.\n"
},
{
"path": "vendor/dario.cat/mergo/doc.go",
"content": "// Copyright 2013 Dario Castaรฑรฉ. All rights reserved.\n// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n/*\nA helper to merge structs and maps in Golang. Useful for configuration default values, avoiding messy if-statements.\n\nMergo merges same-type structs and maps by setting default values in zero-value fields. Mergo won't merge unexported (private) fields. It will do recursively any exported one. It also won't merge structs inside maps (because they are not addressable using Go reflection).\n\n# Status\n\nIt is ready for production use. It is used in several projects by Docker, Google, The Linux Foundation, VMWare, Shopify, etc.\n\n# Important notes\n\n1.0.0\n\nIn 1.0.0 Mergo moves to a vanity URL `dario.cat/mergo`.\n\n0.3.9\n\nPlease keep in mind that a problematic PR broke 0.3.9. We reverted it in 0.3.10. We consider 0.3.10 as stable but not bug-free. . Also, this version adds suppot for go modules.\n\nKeep in mind that in 0.3.2, Mergo changed Merge() and Map() signatures to support transformers. We added an optional/variadic argument so that it won't break the existing code.\n\nIf you were using Mergo before April 6th, 2015, please check your project works as intended after updating your local copy with go get -u dario.cat/mergo. I apologize for any issue caused by its previous behavior and any future bug that Mergo could cause in existing projects after the change (release 0.2.0).\n\n# Install\n\nDo your usual installation procedure:\n\n\tgo get dario.cat/mergo\n\n\t// use in your .go code\n\timport (\n\t \"dario.cat/mergo\"\n\t)\n\n# Usage\n\nYou can only merge same-type structs with exported fields initialized as zero value of their type and same-types maps. Mergo won't merge unexported (private) fields but will do recursively any exported one. It won't merge empty structs value as they are zero values too. Also, maps will be merged recursively except for structs inside maps (because they are not addressable using Go reflection).\n\n\tif err := mergo.Merge(&dst, src); err != nil {\n\t\t// ...\n\t}\n\nAlso, you can merge overwriting values using the transformer WithOverride.\n\n\tif err := mergo.Merge(&dst, src, mergo.WithOverride); err != nil {\n\t\t// ...\n\t}\n\nAdditionally, you can map a map[string]interface{} to a struct (and otherwise, from struct to map), following the same restrictions as in Merge(). Keys are capitalized to find each corresponding exported field.\n\n\tif err := mergo.Map(&dst, srcMap); err != nil {\n\t\t// ...\n\t}\n\nWarning: if you map a struct to map, it won't do it recursively. Don't expect Mergo to map struct members of your struct as map[string]interface{}. They will be just assigned as values.\n\nHere is a nice example:\n\n\tpackage main\n\n\timport (\n\t\t\"fmt\"\n\t\t\"dario.cat/mergo\"\n\t)\n\n\ttype Foo struct {\n\t\tA string\n\t\tB int64\n\t}\n\n\tfunc main() {\n\t\tsrc := Foo{\n\t\t\tA: \"one\",\n\t\t\tB: 2,\n\t\t}\n\t\tdest := Foo{\n\t\t\tA: \"two\",\n\t\t}\n\t\tmergo.Merge(&dest, src)\n\t\tfmt.Println(dest)\n\t\t// Will print\n\t\t// {two 2}\n\t}\n\n# Transformers\n\nTransformers allow to merge specific types differently than in the default behavior. In other words, now you can customize how some types are merged. For example, time.Time is a struct; it doesn't have zero value but IsZero can return true because it has fields with zero value. How can we merge a non-zero time.Time?\n\n\tpackage main\n\n\timport (\n\t\t\"fmt\"\n\t\t\"dario.cat/mergo\"\n\t\t\"reflect\"\n\t\t\"time\"\n\t)\n\n\ttype timeTransformer struct {\n\t}\n\n\tfunc (t timeTransformer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error {\n\t\tif typ == reflect.TypeOf(time.Time{}) {\n\t\t\treturn func(dst, src reflect.Value) error {\n\t\t\t\tif dst.CanSet() {\n\t\t\t\t\tisZero := dst.MethodByName(\"IsZero\")\n\t\t\t\t\tresult := isZero.Call([]reflect.Value{})\n\t\t\t\t\tif result[0].Bool() {\n\t\t\t\t\t\tdst.Set(src)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn nil\n\t\t\t}\n\t\t}\n\t\treturn nil\n\t}\n\n\ttype Snapshot struct {\n\t\tTime time.Time\n\t\t// ...\n\t}\n\n\tfunc main() {\n\t\tsrc := Snapshot{time.Now()}\n\t\tdest := Snapshot{}\n\t\tmergo.Merge(&dest, src, mergo.WithTransformers(timeTransformer{}))\n\t\tfmt.Println(dest)\n\t\t// Will print\n\t\t// { 2018-01-12 01:15:00 +0000 UTC m=+0.000000001 }\n\t}\n\n# Contact me\n\nIf I can help you, you have an idea or you are using Mergo in your projects, don't hesitate to drop me a line (or a pull request): https://twitter.com/im_dario\n\n# About\n\nWritten by Dario Castaรฑรฉ: https://da.rio.hn\n\n# License\n\nBSD 3-Clause license, as Go language.\n*/\npackage mergo\n"
},
{
"path": "vendor/dario.cat/mergo/map.go",
"content": "// Copyright 2014 Dario Castaรฑรฉ. All rights reserved.\n// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Based on src/pkg/reflect/deepequal.go from official\n// golang's stdlib.\n\npackage mergo\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n\t\"unicode\"\n\t\"unicode/utf8\"\n)\n\nfunc changeInitialCase(s string, mapper func(rune) rune) string {\n\tif s == \"\" {\n\t\treturn s\n\t}\n\tr, n := utf8.DecodeRuneInString(s)\n\treturn string(mapper(r)) + s[n:]\n}\n\nfunc isExported(field reflect.StructField) bool {\n\tr, _ := utf8.DecodeRuneInString(field.Name)\n\treturn r >= 'A' && r <= 'Z'\n}\n\n// Traverses recursively both values, assigning src's fields values to dst.\n// The map argument tracks comparisons that have already been seen, which allows\n// short circuiting on recursive types.\nfunc deepMap(dst, src reflect.Value, visited map[uintptr]*visit, depth int, config *Config) (err error) {\n\toverwrite := config.Overwrite\n\tif dst.CanAddr() {\n\t\taddr := dst.UnsafeAddr()\n\t\th := 17 * addr\n\t\tseen := visited[h]\n\t\ttyp := dst.Type()\n\t\tfor p := seen; p != nil; p = p.next {\n\t\t\tif p.ptr == addr && p.typ == typ {\n\t\t\t\treturn nil\n\t\t\t}\n\t\t}\n\t\t// Remember, remember...\n\t\tvisited[h] = &visit{typ, seen, addr}\n\t}\n\tzeroValue := reflect.Value{}\n\tswitch dst.Kind() {\n\tcase reflect.Map:\n\t\tdstMap := dst.Interface().(map[string]interface{})\n\t\tfor i, n := 0, src.NumField(); i < n; i++ {\n\t\t\tsrcType := src.Type()\n\t\t\tfield := srcType.Field(i)\n\t\t\tif !isExported(field) {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tfieldName := field.Name\n\t\t\tfieldName = changeInitialCase(fieldName, unicode.ToLower)\n\t\t\tif _, ok := dstMap[fieldName]; !ok || (!isEmptyValue(reflect.ValueOf(src.Field(i).Interface()), !config.ShouldNotDereference) && overwrite) || config.overwriteWithEmptyValue {\n\t\t\t\tdstMap[fieldName] = src.Field(i).Interface()\n\t\t\t}\n\t\t}\n\tcase reflect.Ptr:\n\t\tif dst.IsNil() {\n\t\t\tv := reflect.New(dst.Type().Elem())\n\t\t\tdst.Set(v)\n\t\t}\n\t\tdst = dst.Elem()\n\t\tfallthrough\n\tcase reflect.Struct:\n\t\tsrcMap := src.Interface().(map[string]interface{})\n\t\tfor key := range srcMap {\n\t\t\tconfig.overwriteWithEmptyValue = true\n\t\t\tsrcValue := srcMap[key]\n\t\t\tfieldName := changeInitialCase(key, unicode.ToUpper)\n\t\t\tdstElement := dst.FieldByName(fieldName)\n\t\t\tif dstElement == zeroValue {\n\t\t\t\t// We discard it because the field doesn't exist.\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tsrcElement := reflect.ValueOf(srcValue)\n\t\t\tdstKind := dstElement.Kind()\n\t\t\tsrcKind := srcElement.Kind()\n\t\t\tif srcKind == reflect.Ptr && dstKind != reflect.Ptr {\n\t\t\t\tsrcElement = srcElement.Elem()\n\t\t\t\tsrcKind = reflect.TypeOf(srcElement.Interface()).Kind()\n\t\t\t} else if dstKind == reflect.Ptr {\n\t\t\t\t// Can this work? I guess it can't.\n\t\t\t\tif srcKind != reflect.Ptr && srcElement.CanAddr() {\n\t\t\t\t\tsrcPtr := srcElement.Addr()\n\t\t\t\t\tsrcElement = reflect.ValueOf(srcPtr)\n\t\t\t\t\tsrcKind = reflect.Ptr\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif !srcElement.IsValid() {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif srcKind == dstKind {\n\t\t\t\tif err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t} else if dstKind == reflect.Interface && dstElement.Kind() == reflect.Interface {\n\t\t\t\tif err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t} else if srcKind == reflect.Map {\n\t\t\t\tif err = deepMap(dstElement, srcElement, visited, depth+1, config); err != nil {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\treturn fmt.Errorf(\"type mismatch on %s field: found %v, expected %v\", fieldName, srcKind, dstKind)\n\t\t\t}\n\t\t}\n\t}\n\treturn\n}\n\n// Map sets fields' values in dst from src.\n// src can be a map with string keys or a struct. dst must be the opposite:\n// if src is a map, dst must be a valid pointer to struct. If src is a struct,\n// dst must be map[string]interface{}.\n// It won't merge unexported (private) fields and will do recursively\n// any exported field.\n// If dst is a map, keys will be src fields' names in lower camel case.\n// Missing key in src that doesn't match a field in dst will be skipped. This\n// doesn't apply if dst is a map.\n// This is separated method from Merge because it is cleaner and it keeps sane\n// semantics: merging equal types, mapping different (restricted) types.\nfunc Map(dst, src interface{}, opts ...func(*Config)) error {\n\treturn _map(dst, src, opts...)\n}\n\n// MapWithOverwrite will do the same as Map except that non-empty dst attributes will be overridden by\n// non-empty src attribute values.\n// Deprecated: Use Map(โฆ) with WithOverride\nfunc MapWithOverwrite(dst, src interface{}, opts ...func(*Config)) error {\n\treturn _map(dst, src, append(opts, WithOverride)...)\n}\n\nfunc _map(dst, src interface{}, opts ...func(*Config)) error {\n\tif dst != nil && reflect.ValueOf(dst).Kind() != reflect.Ptr {\n\t\treturn ErrNonPointerArgument\n\t}\n\tvar (\n\t\tvDst, vSrc reflect.Value\n\t\terr error\n\t)\n\tconfig := &Config{}\n\n\tfor _, opt := range opts {\n\t\topt(config)\n\t}\n\n\tif vDst, vSrc, err = resolveValues(dst, src); err != nil {\n\t\treturn err\n\t}\n\t// To be friction-less, we redirect equal-type arguments\n\t// to deepMerge. Only because arguments can be anything.\n\tif vSrc.Kind() == vDst.Kind() {\n\t\treturn deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0, config)\n\t}\n\tswitch vSrc.Kind() {\n\tcase reflect.Struct:\n\t\tif vDst.Kind() != reflect.Map {\n\t\t\treturn ErrExpectedMapAsDestination\n\t\t}\n\tcase reflect.Map:\n\t\tif vDst.Kind() != reflect.Struct {\n\t\t\treturn ErrExpectedStructAsDestination\n\t\t}\n\tdefault:\n\t\treturn ErrNotSupported\n\t}\n\treturn deepMap(vDst, vSrc, make(map[uintptr]*visit), 0, config)\n}\n"
},
{
"path": "vendor/dario.cat/mergo/merge.go",
"content": "// Copyright 2013 Dario Castaรฑรฉ. All rights reserved.\n// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Based on src/pkg/reflect/deepequal.go from official\n// golang's stdlib.\n\npackage mergo\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n)\n\nfunc hasMergeableFields(dst reflect.Value) (exported bool) {\n\tfor i, n := 0, dst.NumField(); i < n; i++ {\n\t\tfield := dst.Type().Field(i)\n\t\tif field.Anonymous && dst.Field(i).Kind() == reflect.Struct {\n\t\t\texported = exported || hasMergeableFields(dst.Field(i))\n\t\t} else if isExportedComponent(&field) {\n\t\t\texported = exported || len(field.PkgPath) == 0\n\t\t}\n\t}\n\treturn\n}\n\nfunc isExportedComponent(field *reflect.StructField) bool {\n\tpkgPath := field.PkgPath\n\tif len(pkgPath) > 0 {\n\t\treturn false\n\t}\n\tc := field.Name[0]\n\tif 'a' <= c && c <= 'z' || c == '_' {\n\t\treturn false\n\t}\n\treturn true\n}\n\ntype Config struct {\n\tTransformers Transformers\n\tOverwrite bool\n\tShouldNotDereference bool\n\tAppendSlice bool\n\tTypeCheck bool\n\toverwriteWithEmptyValue bool\n\toverwriteSliceWithEmptyValue bool\n\tsliceDeepCopy bool\n\tdebug bool\n}\n\ntype Transformers interface {\n\tTransformer(reflect.Type) func(dst, src reflect.Value) error\n}\n\n// Traverses recursively both values, assigning src's fields values to dst.\n// The map argument tracks comparisons that have already been seen, which allows\n// short circuiting on recursive types.\nfunc deepMerge(dst, src reflect.Value, visited map[uintptr]*visit, depth int, config *Config) (err error) {\n\toverwrite := config.Overwrite\n\ttypeCheck := config.TypeCheck\n\toverwriteWithEmptySrc := config.overwriteWithEmptyValue\n\toverwriteSliceWithEmptySrc := config.overwriteSliceWithEmptyValue\n\tsliceDeepCopy := config.sliceDeepCopy\n\n\tif !src.IsValid() {\n\t\treturn\n\t}\n\tif dst.CanAddr() {\n\t\taddr := dst.UnsafeAddr()\n\t\th := 17 * addr\n\t\tseen := visited[h]\n\t\ttyp := dst.Type()\n\t\tfor p := seen; p != nil; p = p.next {\n\t\t\tif p.ptr == addr && p.typ == typ {\n\t\t\t\treturn nil\n\t\t\t}\n\t\t}\n\t\t// Remember, remember...\n\t\tvisited[h] = &visit{typ, seen, addr}\n\t}\n\n\tif config.Transformers != nil && !isReflectNil(dst) && dst.IsValid() {\n\t\tif fn := config.Transformers.Transformer(dst.Type()); fn != nil {\n\t\t\terr = fn(dst, src)\n\t\t\treturn\n\t\t}\n\t}\n\n\tswitch dst.Kind() {\n\tcase reflect.Struct:\n\t\tif hasMergeableFields(dst) {\n\t\t\tfor i, n := 0, dst.NumField(); i < n; i++ {\n\t\t\t\tif err = deepMerge(dst.Field(i), src.Field(i), visited, depth+1, config); err != nil {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tif dst.CanSet() && (isReflectNil(dst) || overwrite) && (!isEmptyValue(src, !config.ShouldNotDereference) || overwriteWithEmptySrc) {\n\t\t\t\tdst.Set(src)\n\t\t\t}\n\t\t}\n\tcase reflect.Map:\n\t\tif dst.IsNil() && !src.IsNil() {\n\t\t\tif dst.CanSet() {\n\t\t\t\tdst.Set(reflect.MakeMap(dst.Type()))\n\t\t\t} else {\n\t\t\t\tdst = src\n\t\t\t\treturn\n\t\t\t}\n\t\t}\n\n\t\tif src.Kind() != reflect.Map {\n\t\t\tif overwrite && dst.CanSet() {\n\t\t\t\tdst.Set(src)\n\t\t\t}\n\t\t\treturn\n\t\t}\n\n\t\tfor _, key := range src.MapKeys() {\n\t\t\tsrcElement := src.MapIndex(key)\n\t\t\tif !srcElement.IsValid() {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tdstElement := dst.MapIndex(key)\n\t\t\tswitch srcElement.Kind() {\n\t\t\tcase reflect.Chan, reflect.Func, reflect.Map, reflect.Interface, reflect.Slice:\n\t\t\t\tif srcElement.IsNil() {\n\t\t\t\t\tif overwrite {\n\t\t\t\t\t\tdst.SetMapIndex(key, srcElement)\n\t\t\t\t\t}\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\tfallthrough\n\t\t\tdefault:\n\t\t\t\tif !srcElement.CanInterface() {\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\tswitch reflect.TypeOf(srcElement.Interface()).Kind() {\n\t\t\t\tcase reflect.Struct:\n\t\t\t\t\tfallthrough\n\t\t\t\tcase reflect.Ptr:\n\t\t\t\t\tfallthrough\n\t\t\t\tcase reflect.Map:\n\t\t\t\t\tsrcMapElm := srcElement\n\t\t\t\t\tdstMapElm := dstElement\n\t\t\t\t\tif srcMapElm.CanInterface() {\n\t\t\t\t\t\tsrcMapElm = reflect.ValueOf(srcMapElm.Interface())\n\t\t\t\t\t\tif dstMapElm.IsValid() {\n\t\t\t\t\t\t\tdstMapElm = reflect.ValueOf(dstMapElm.Interface())\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif err = deepMerge(dstMapElm, srcMapElm, visited, depth+1, config); err != nil {\n\t\t\t\t\t\treturn\n\t\t\t\t\t}\n\t\t\t\tcase reflect.Slice:\n\t\t\t\t\tsrcSlice := reflect.ValueOf(srcElement.Interface())\n\n\t\t\t\t\tvar dstSlice reflect.Value\n\t\t\t\t\tif !dstElement.IsValid() || dstElement.IsNil() {\n\t\t\t\t\t\tdstSlice = reflect.MakeSlice(srcSlice.Type(), 0, srcSlice.Len())\n\t\t\t\t\t} else {\n\t\t\t\t\t\tdstSlice = reflect.ValueOf(dstElement.Interface())\n\t\t\t\t\t}\n\n\t\t\t\t\tif (!isEmptyValue(src, !config.ShouldNotDereference) || overwriteWithEmptySrc || overwriteSliceWithEmptySrc) && (overwrite || isEmptyValue(dst, !config.ShouldNotDereference)) && !config.AppendSlice && !sliceDeepCopy {\n\t\t\t\t\t\tif typeCheck && srcSlice.Type() != dstSlice.Type() {\n\t\t\t\t\t\t\treturn fmt.Errorf(\"cannot override two slices with different type (%s, %s)\", srcSlice.Type(), dstSlice.Type())\n\t\t\t\t\t\t}\n\t\t\t\t\t\tdstSlice = srcSlice\n\t\t\t\t\t} else if config.AppendSlice {\n\t\t\t\t\t\tif srcSlice.Type() != dstSlice.Type() {\n\t\t\t\t\t\t\treturn fmt.Errorf(\"cannot append two slices with different type (%s, %s)\", srcSlice.Type(), dstSlice.Type())\n\t\t\t\t\t\t}\n\t\t\t\t\t\tdstSlice = reflect.AppendSlice(dstSlice, srcSlice)\n\t\t\t\t\t} else if sliceDeepCopy {\n\t\t\t\t\t\ti := 0\n\t\t\t\t\t\tfor ; i < srcSlice.Len() && i < dstSlice.Len(); i++ {\n\t\t\t\t\t\t\tsrcElement := srcSlice.Index(i)\n\t\t\t\t\t\t\tdstElement := dstSlice.Index(i)\n\n\t\t\t\t\t\t\tif srcElement.CanInterface() {\n\t\t\t\t\t\t\t\tsrcElement = reflect.ValueOf(srcElement.Interface())\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif dstElement.CanInterface() {\n\t\t\t\t\t\t\t\tdstElement = reflect.ValueOf(dstElement.Interface())\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tif err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {\n\t\t\t\t\t\t\t\treturn\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\t\t\t\t\tdst.SetMapIndex(key, dstSlice)\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif dstElement.IsValid() && !isEmptyValue(dstElement, !config.ShouldNotDereference) {\n\t\t\t\tif reflect.TypeOf(srcElement.Interface()).Kind() == reflect.Slice {\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\tif reflect.TypeOf(srcElement.Interface()).Kind() == reflect.Map && reflect.TypeOf(dstElement.Interface()).Kind() == reflect.Map {\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif srcElement.IsValid() && ((srcElement.Kind() != reflect.Ptr && overwrite) || !dstElement.IsValid() || isEmptyValue(dstElement, !config.ShouldNotDereference)) {\n\t\t\t\tif dst.IsNil() {\n\t\t\t\t\tdst.Set(reflect.MakeMap(dst.Type()))\n\t\t\t\t}\n\t\t\t\tdst.SetMapIndex(key, srcElement)\n\t\t\t}\n\t\t}\n\n\t\t// Ensure that all keys in dst are deleted if they are not in src.\n\t\tif overwriteWithEmptySrc {\n\t\t\tfor _, key := range dst.MapKeys() {\n\t\t\t\tsrcElement := src.MapIndex(key)\n\t\t\t\tif !srcElement.IsValid() {\n\t\t\t\t\tdst.SetMapIndex(key, reflect.Value{})\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\tcase reflect.Slice:\n\t\tif !dst.CanSet() {\n\t\t\tbreak\n\t\t}\n\t\tif (!isEmptyValue(src, !config.ShouldNotDereference) || overwriteWithEmptySrc || overwriteSliceWithEmptySrc) && (overwrite || isEmptyValue(dst, !config.ShouldNotDereference)) && !config.AppendSlice && !sliceDeepCopy {\n\t\t\tdst.Set(src)\n\t\t} else if config.AppendSlice {\n\t\t\tif src.Type() != dst.Type() {\n\t\t\t\treturn fmt.Errorf(\"cannot append two slice with different type (%s, %s)\", src.Type(), dst.Type())\n\t\t\t}\n\t\t\tdst.Set(reflect.AppendSlice(dst, src))\n\t\t} else if sliceDeepCopy {\n\t\t\tfor i := 0; i < src.Len() && i < dst.Len(); i++ {\n\t\t\t\tsrcElement := src.Index(i)\n\t\t\t\tdstElement := dst.Index(i)\n\t\t\t\tif srcElement.CanInterface() {\n\t\t\t\t\tsrcElement = reflect.ValueOf(srcElement.Interface())\n\t\t\t\t}\n\t\t\t\tif dstElement.CanInterface() {\n\t\t\t\t\tdstElement = reflect.ValueOf(dstElement.Interface())\n\t\t\t\t}\n\n\t\t\t\tif err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\tcase reflect.Ptr:\n\t\tfallthrough\n\tcase reflect.Interface:\n\t\tif isReflectNil(src) {\n\t\t\tif overwriteWithEmptySrc && dst.CanSet() && src.Type().AssignableTo(dst.Type()) {\n\t\t\t\tdst.Set(src)\n\t\t\t}\n\t\t\tbreak\n\t\t}\n\n\t\tif src.Kind() != reflect.Interface {\n\t\t\tif dst.IsNil() || (src.Kind() != reflect.Ptr && overwrite) {\n\t\t\t\tif dst.CanSet() && (overwrite || isEmptyValue(dst, !config.ShouldNotDereference)) {\n\t\t\t\t\tdst.Set(src)\n\t\t\t\t}\n\t\t\t} else if src.Kind() == reflect.Ptr {\n\t\t\t\tif !config.ShouldNotDereference {\n\t\t\t\t\tif err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil {\n\t\t\t\t\t\treturn\n\t\t\t\t\t}\n\t\t\t\t} else if src.Elem().Kind() != reflect.Struct {\n\t\t\t\t\tif overwriteWithEmptySrc || (overwrite && !src.IsNil()) || dst.IsNil() {\n\t\t\t\t\t\tdst.Set(src)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if dst.Elem().Type() == src.Type() {\n\t\t\t\tif err = deepMerge(dst.Elem(), src, visited, depth+1, config); err != nil {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\treturn ErrDifferentArgumentsTypes\n\t\t\t}\n\t\t\tbreak\n\t\t}\n\n\t\tif dst.IsNil() || overwrite {\n\t\t\tif dst.CanSet() && (overwrite || isEmptyValue(dst, !config.ShouldNotDereference)) {\n\t\t\t\tdst.Set(src)\n\t\t\t}\n\t\t\tbreak\n\t\t}\n\n\t\tif dst.Elem().Kind() == src.Elem().Kind() {\n\t\t\tif err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil {\n\t\t\t\treturn\n\t\t\t}\n\t\t\tbreak\n\t\t}\n\tdefault:\n\t\tmustSet := (isEmptyValue(dst, !config.ShouldNotDereference) || overwrite) && (!isEmptyValue(src, !config.ShouldNotDereference) || overwriteWithEmptySrc)\n\t\tif mustSet {\n\t\t\tif dst.CanSet() {\n\t\t\t\tdst.Set(src)\n\t\t\t} else {\n\t\t\t\tdst = src\n\t\t\t}\n\t\t}\n\t}\n\n\treturn\n}\n\n// Merge will fill any empty for value type attributes on the dst struct using corresponding\n// src attributes if they themselves are not empty. dst and src must be valid same-type structs\n// and dst must be a pointer to struct.\n// It won't merge unexported (private) fields and will do recursively any exported field.\nfunc Merge(dst, src interface{}, opts ...func(*Config)) error {\n\treturn merge(dst, src, opts...)\n}\n\n// MergeWithOverwrite will do the same as Merge except that non-empty dst attributes will be overridden by\n// non-empty src attribute values.\n// Deprecated: use Merge(โฆ) with WithOverride\nfunc MergeWithOverwrite(dst, src interface{}, opts ...func(*Config)) error {\n\treturn merge(dst, src, append(opts, WithOverride)...)\n}\n\n// WithTransformers adds transformers to merge, allowing to customize the merging of some types.\nfunc WithTransformers(transformers Transformers) func(*Config) {\n\treturn func(config *Config) {\n\t\tconfig.Transformers = transformers\n\t}\n}\n\n// WithOverride will make merge override non-empty dst attributes with non-empty src attributes values.\nfunc WithOverride(config *Config) {\n\tconfig.Overwrite = true\n}\n\n// WithOverwriteWithEmptyValue will make merge override non empty dst attributes with empty src attributes values.\nfunc WithOverwriteWithEmptyValue(config *Config) {\n\tconfig.Overwrite = true\n\tconfig.overwriteWithEmptyValue = true\n}\n\n// WithOverrideEmptySlice will make merge override empty dst slice with empty src slice.\nfunc WithOverrideEmptySlice(config *Config) {\n\tconfig.overwriteSliceWithEmptyValue = true\n}\n\n// WithoutDereference prevents dereferencing pointers when evaluating whether they are empty\n// (i.e. a non-nil pointer is never considered empty).\nfunc WithoutDereference(config *Config) {\n\tconfig.ShouldNotDereference = true\n}\n\n// WithAppendSlice will make merge append slices instead of overwriting it.\nfunc WithAppendSlice(config *Config) {\n\tconfig.AppendSlice = true\n}\n\n// WithTypeCheck will make merge check types while overwriting it (must be used with WithOverride).\nfunc WithTypeCheck(config *Config) {\n\tconfig.TypeCheck = true\n}\n\n// WithSliceDeepCopy will merge slice element one by one with Overwrite flag.\nfunc WithSliceDeepCopy(config *Config) {\n\tconfig.sliceDeepCopy = true\n\tconfig.Overwrite = true\n}\n\nfunc merge(dst, src interface{}, opts ...func(*Config)) error {\n\tif dst != nil && reflect.ValueOf(dst).Kind() != reflect.Ptr {\n\t\treturn ErrNonPointerArgument\n\t}\n\tvar (\n\t\tvDst, vSrc reflect.Value\n\t\terr error\n\t)\n\n\tconfig := &Config{}\n\n\tfor _, opt := range opts {\n\t\topt(config)\n\t}\n\n\tif vDst, vSrc, err = resolveValues(dst, src); err != nil {\n\t\treturn err\n\t}\n\tif vDst.Type() != vSrc.Type() {\n\t\treturn ErrDifferentArgumentsTypes\n\t}\n\treturn deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0, config)\n}\n\n// IsReflectNil is the reflect value provided nil\nfunc isReflectNil(v reflect.Value) bool {\n\tk := v.Kind()\n\tswitch k {\n\tcase reflect.Interface, reflect.Slice, reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr:\n\t\t// Both interface and slice are nil if first word is 0.\n\t\t// Both are always bigger than a word; assume flagIndir.\n\t\treturn v.IsNil()\n\tdefault:\n\t\treturn false\n\t}\n}\n"
},
{
"path": "vendor/dario.cat/mergo/mergo.go",
"content": "// Copyright 2013 Dario Castaรฑรฉ. All rights reserved.\n// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Based on src/pkg/reflect/deepequal.go from official\n// golang's stdlib.\n\npackage mergo\n\nimport (\n\t\"errors\"\n\t\"reflect\"\n)\n\n// Errors reported by Mergo when it finds invalid arguments.\nvar (\n\tErrNilArguments = errors.New(\"src and dst must not be nil\")\n\tErrDifferentArgumentsTypes = errors.New(\"src and dst must be of same type\")\n\tErrNotSupported = errors.New(\"only structs, maps, and slices are supported\")\n\tErrExpectedMapAsDestination = errors.New(\"dst was expected to be a map\")\n\tErrExpectedStructAsDestination = errors.New(\"dst was expected to be a struct\")\n\tErrNonPointerArgument = errors.New(\"dst must be a pointer\")\n)\n\n// During deepMerge, must keep track of checks that are\n// in progress. The comparison algorithm assumes that all\n// checks in progress are true when it reencounters them.\n// Visited are stored in a map indexed by 17 * a1 + a2;\ntype visit struct {\n\ttyp reflect.Type\n\tnext *visit\n\tptr uintptr\n}\n\n// From src/pkg/encoding/json/encode.go.\nfunc isEmptyValue(v reflect.Value, shouldDereference bool) bool {\n\tswitch v.Kind() {\n\tcase reflect.Array, reflect.Map, reflect.Slice, reflect.String:\n\t\treturn v.Len() == 0\n\tcase reflect.Bool:\n\t\treturn !v.Bool()\n\tcase reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:\n\t\treturn v.Int() == 0\n\tcase reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:\n\t\treturn v.Uint() == 0\n\tcase reflect.Float32, reflect.Float64:\n\t\treturn v.Float() == 0\n\tcase reflect.Interface, reflect.Ptr:\n\t\tif v.IsNil() {\n\t\t\treturn true\n\t\t}\n\t\tif shouldDereference {\n\t\t\treturn isEmptyValue(v.Elem(), shouldDereference)\n\t\t}\n\t\treturn false\n\tcase reflect.Func:\n\t\treturn v.IsNil()\n\tcase reflect.Invalid:\n\t\treturn true\n\t}\n\treturn false\n}\n\nfunc resolveValues(dst, src interface{}) (vDst, vSrc reflect.Value, err error) {\n\tif dst == nil || src == nil {\n\t\terr = ErrNilArguments\n\t\treturn\n\t}\n\tvDst = reflect.ValueOf(dst).Elem()\n\tif vDst.Kind() != reflect.Struct && vDst.Kind() != reflect.Map && vDst.Kind() != reflect.Slice {\n\t\terr = ErrNotSupported\n\t\treturn\n\t}\n\tvSrc = reflect.ValueOf(src)\n\t// We check if vSrc is a pointer to dereference it.\n\tif vSrc.Kind() == reflect.Ptr {\n\t\tvSrc = vSrc.Elem()\n\t}\n\treturn\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/LICENSE.txt",
"content": "The MIT License (MIT)\n\nCopyright (c) Microsoft Corporation.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/NOTICE.txt",
"content": "NOTICES AND INFORMATION\nDo Not Translate or Localize\n\nThis software incorporates material from third parties. Microsoft makes certain\nopen source code available at https://3rdpartysource.microsoft.com, or you may\nsend a check or money order for US $5.00, including the product name, the open\nsource component name, and version number, to:\n\nSource Code Compliance Team\nMicrosoft Corporation\nOne Microsoft Way\nRedmond, WA 98052\nUSA\n\nNotwithstanding any other terms, you may reverse engineer this software to the\nextent required to debug changes to any libraries licensed under the GNU Lesser\nGeneral Public License.\n\n------------------------------------------------------------------------------\n\nAzure SDK for Go uses third-party libraries or other resources that may be\ndistributed under licenses different than the Azure SDK for Go software.\n\nIn the event that we accidentally failed to list a required notice, please\nbring it to our attention. Post an issue or email us:\n\n azgosdkhelp@microsoft.com\n\nThe attached notices are provided for information only.\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/CHANGELOG.md",
"content": "# Release History\n\n## 1.18.0 (2025-04-03)\n\n### Features Added\n\n* Added `AccessToken.RefreshOn` and updated `BearerTokenPolicy` to consider nonzero values of it when deciding whether to request a new token\n\n\n## 1.17.1 (2025-03-20)\n\n### Other Changes\n\n* Upgraded to Go 1.23\n* Upgraded dependencies\n\n## 1.17.0 (2025-01-07)\n\n### Features Added\n\n* Added field `OperationLocationResultPath` to `runtime.NewPollerOptions[T]` for LROs that use the `Operation-Location` pattern.\n* Support `encoding.TextMarshaler` and `encoding.TextUnmarshaler` interfaces in `arm.ResourceID`.\n\n## 1.16.0 (2024-10-17)\n\n### Features Added\n\n* Added field `Kind` to `runtime.StartSpanOptions` to allow a kind to be set when starting a span.\n\n### Bugs Fixed\n\n* `BearerTokenPolicy` now rewinds request bodies before retrying\n\n## 1.15.0 (2024-10-14)\n\n### Features Added\n\n* `BearerTokenPolicy` handles CAE claims challenges\n\n### Bugs Fixed\n\n* Omit the `ResponseError.RawResponse` field from JSON marshaling so instances can be marshaled.\n* Fixed an integer overflow in the retry policy.\n\n### Other Changes\n\n* Update dependencies.\n\n## 1.14.0 (2024-08-07)\n\n### Features Added\n\n* Added field `Attributes` to `runtime.StartSpanOptions` to simplify creating spans with attributes.\n\n### Other Changes\n\n* Include the HTTP verb and URL in `log.EventRetryPolicy` log entries so it's clear which operation is being retried.\n\n## 1.13.0 (2024-07-16)\n\n### Features Added\n\n- Added runtime.NewRequestFromRequest(), allowing for a policy.Request to be created from an existing *http.Request.\n\n## 1.12.0 (2024-06-06)\n\n### Features Added\n\n* Added field `StatusCodes` to `runtime.FetcherForNextLinkOptions` allowing for additional HTTP status codes indicating success.\n* Added func `NewUUID` to the `runtime` package for generating UUIDs.\n\n### Bugs Fixed\n\n* Fixed an issue that prevented pollers using the `Operation-Location` strategy from unmarshaling the final result in some cases.\n\n### Other Changes\n\n* Updated dependencies.\n\n## 1.11.1 (2024-04-02)\n\n### Bugs Fixed\n\n* Pollers that use the `Location` header won't consider `http.StatusRequestTimeout` a terminal failure.\n* `runtime.Poller[T].Result` won't consider non-terminal error responses as terminal.\n\n## 1.11.0 (2024-04-01)\n\n### Features Added\n\n* Added `StatusCodes` to `arm/policy.RegistrationOptions` to allow supporting non-standard HTTP status codes during registration.\n* Added field `InsecureAllowCredentialWithHTTP` to `azcore.ClientOptions` and dependent authentication pipeline policies.\n* Added type `MultipartContent` to the `streaming` package to support multipart/form payloads with custom Content-Type and file name.\n\n### Bugs Fixed\n\n* `runtime.SetMultipartFormData` won't try to stringify `[]byte` values.\n* Pollers that use the `Location` header won't consider `http.StatusTooManyRequests` a terminal failure.\n\n### Other Changes\n\n* Update dependencies.\n\n## 1.10.0 (2024-02-29)\n\n### Features Added\n\n* Added logging event `log.EventResponseError` that will contain the contents of `ResponseError.Error()` whenever an `azcore.ResponseError` is created.\n* Added `runtime.NewResponseErrorWithErrorCode` for creating an `azcore.ResponseError` with a caller-supplied error code.\n* Added type `MatchConditions` for use in conditional requests.\n\n### Bugs Fixed\n\n* Fixed a potential race condition between `NullValue` and `IsNullValue`.\n* `runtime.EncodeQueryParams` will escape semicolons before calling `url.ParseQuery`.\n\n### Other Changes\n\n* Update dependencies.\n\n## 1.9.2 (2024-02-06)\n\n### Bugs Fixed\n\n* `runtime.MarshalAsByteArray` and `runtime.MarshalAsJSON` will preserve the preexisting value of the `Content-Type` header.\n\n### Other Changes\n\n* Update to latest version of `internal`.\n\n## 1.9.1 (2023-12-11)\n\n### Bugs Fixed\n\n* The `retry-after-ms` and `x-ms-retry-after-ms` headers weren't being checked during retries.\n\n### Other Changes\n\n* Update dependencies.\n\n## 1.9.0 (2023-11-06)\n\n### Breaking Changes\n> These changes affect only code written against previous beta versions of `v1.7.0` and `v1.8.0`\n* The function `NewTokenCredential` has been removed from the `fake` package. Use a literal `&fake.TokenCredential{}` instead.\n* The field `TracingNamespace` in `runtime.PipelineOptions` has been replaced by `TracingOptions`.\n\n### Bugs Fixed\n\n* Fixed an issue that could cause some allowed HTTP header values to not show up in logs.\n* Include error text instead of error type in traces when the transport returns an error.\n* Fixed an issue that could cause an HTTP/2 request to hang when the TCP connection becomes unresponsive.\n* Block key and SAS authentication for non TLS protected endpoints.\n* Passing a `nil` credential value will no longer cause a panic. Instead, the authentication is skipped.\n* Calling `Error` on a zero-value `azcore.ResponseError` will no longer panic.\n* Fixed an issue in `fake.PagerResponder[T]` that would cause a trailing error to be omitted when iterating over pages.\n* Context values created by `azcore` will no longer flow across disjoint HTTP requests.\n\n### Other Changes\n\n* Skip generating trace info for no-op tracers.\n* The `clientName` paramater in client constructors has been renamed to `moduleName`.\n\n## 1.9.0-beta.1 (2023-10-05)\n\n### Other Changes\n\n* The beta features for tracing and fakes have been reinstated.\n\n## 1.8.0 (2023-10-05)\n\n### Features Added\n\n* This includes the following features from `v1.8.0-beta.N` releases.\n * Claims and CAE for authentication.\n * New `messaging` package.\n * Various helpers in the `runtime` package.\n * Deprecation of `runtime.With*` funcs and their replacements in the `policy` package.\n* Added types `KeyCredential` and `SASCredential` to the `azcore` package.\n * Includes their respective constructor functions.\n* Added types `KeyCredentialPolicy` and `SASCredentialPolicy` to the `azcore/runtime` package.\n * Includes their respective constructor functions and options types.\n\n### Breaking Changes\n> These changes affect only code written against beta versions of `v1.8.0`\n* The beta features for tracing and fakes have been omitted for this release.\n\n### Bugs Fixed\n\n* Fixed an issue that could cause some ARM RPs to not be automatically registered.\n* Block bearer token authentication for non TLS protected endpoints.\n\n### Other Changes\n\n* Updated dependencies.\n\n## 1.8.0-beta.3 (2023-09-07)\n\n### Features Added\n\n* Added function `FetcherForNextLink` and `FetcherForNextLinkOptions` to the `runtime` package to centralize creation of `Pager[T].Fetcher` from a next link URL.\n\n### Bugs Fixed\n\n* Suppress creating spans for nested SDK API calls. The HTTP span will be a child of the outer API span.\n\n### Other Changes\n\n* The following functions in the `runtime` package are now exposed from the `policy` package, and the `runtime` versions have been deprecated.\n * `WithCaptureResponse`\n * `WithHTTPHeader`\n * `WithRetryOptions`\n\n## 1.7.2 (2023-09-06)\n\n### Bugs Fixed\n\n* Fix default HTTP transport to work in WASM modules.\n\n## 1.8.0-beta.2 (2023-08-14)\n\n### Features Added\n\n* Added function `SanitizePagerPollerPath` to the `server` package to centralize sanitization and formalize the contract.\n* Added `TokenRequestOptions.EnableCAE` to indicate whether to request a CAE token.\n\n### Breaking Changes\n\n> This change affects only code written against beta version `v1.8.0-beta.1`.\n* `messaging.CloudEvent` deserializes JSON objects as `[]byte`, instead of `json.RawMessage`. See the documentation for CloudEvent.Data for more information.\n\n> This change affects only code written against beta versions `v1.7.0-beta.2` and `v1.8.0-beta.1`.\n* Removed parameter from method `Span.End()` and its type `tracing.SpanEndOptions`. This API GA'ed in `v1.2.0` so we cannot change it.\n\n### Bugs Fixed\n\n* Propagate any query parameters when constructing a fake poller and/or injecting next links.\n\n## 1.7.1 (2023-08-14)\n\n## Bugs Fixed\n\n* Enable TLS renegotiation in the default transport policy.\n\n## 1.8.0-beta.1 (2023-07-12)\n\n### Features Added\n\n- `messaging/CloudEvent` allows you to serialize/deserialize CloudEvents, as described in the CloudEvents 1.0 specification: [link](https://github.com/cloudevents/spec)\n\n### Other Changes\n\n* The beta features for CAE, tracing, and fakes have been reinstated.\n\n## 1.7.0 (2023-07-12)\n\n### Features Added\n* Added method `WithClientName()` to type `azcore.Client` to support shallow cloning of a client with a new name used for tracing.\n\n### Breaking Changes\n> These changes affect only code written against beta versions v1.7.0-beta.1 or v1.7.0-beta.2\n* The beta features for CAE, tracing, and fakes have been omitted for this release.\n\n## 1.7.0-beta.2 (2023-06-06)\n\n### Breaking Changes\n> These changes affect only code written against beta version v1.7.0-beta.1\n* Method `SpanFromContext()` on type `tracing.Tracer` had the `bool` return value removed.\n * This includes the field `SpanFromContext` in supporting type `tracing.TracerOptions`.\n* Method `AddError()` has been removed from type `tracing.Span`.\n* Method `Span.End()` now requires an argument of type `*tracing.SpanEndOptions`.\n\n## 1.6.1 (2023-06-06)\n\n### Bugs Fixed\n* Fixed an issue in `azcore.NewClient()` and `arm.NewClient()` that could cause an incorrect module name to be used in telemetry.\n\n### Other Changes\n* This version contains all bug fixes from `v1.7.0-beta.1`\n\n## 1.7.0-beta.1 (2023-05-24)\n\n### Features Added\n* Restored CAE support for ARM clients.\n* Added supporting features to enable distributed tracing.\n * Added func `runtime.StartSpan()` for use by SDKs to start spans.\n * Added method `WithContext()` to `runtime.Request` to support shallow cloning with a new context.\n * Added field `TracingNamespace` to `runtime.PipelineOptions`.\n * Added field `Tracer` to `runtime.NewPollerOptions` and `runtime.NewPollerFromResumeTokenOptions` types.\n * Added field `SpanFromContext` to `tracing.TracerOptions`.\n * Added methods `Enabled()`, `SetAttributes()`, and `SpanFromContext()` to `tracing.Tracer`.\n * Added supporting pipeline policies to include HTTP spans when creating clients.\n* Added package `fake` to support generated fakes packages in SDKs.\n * The package contains public surface area exposed by fake servers and supporting APIs intended only for use by the fake server implementations.\n * Added an internal fake poller implementation.\n\n### Bugs Fixed\n* Retry policy always clones the underlying `*http.Request` before invoking the next policy.\n* Added some non-standard error codes to the list of error codes for unregistered resource providers.\n\n## 1.6.0 (2023-05-04)\n\n### Features Added\n* Added support for ARM cross-tenant authentication. Set the `AuxiliaryTenants` field of `arm.ClientOptions` to enable.\n* Added `TenantID` field to `policy.TokenRequestOptions`.\n\n## 1.5.0 (2023-04-06)\n\n### Features Added\n* Added `ShouldRetry` to `policy.RetryOptions` for finer-grained control over when to retry.\n\n### Breaking Changes\n> These changes affect only code written against a beta version such as v1.5.0-beta.1\n> These features will return in v1.6.0-beta.1.\n* Removed `TokenRequestOptions.Claims` and `.TenantID`\n* Removed ARM client support for CAE and cross-tenant auth.\n\n### Bugs Fixed\n* Added non-conformant LRO terminal states `Cancelled` and `Completed`.\n\n### Other Changes\n* Updated to latest `internal` module.\n\n## 1.5.0-beta.1 (2023-03-02)\n\n### Features Added\n* This release includes the features added in v1.4.0-beta.1\n\n## 1.4.0 (2023-03-02)\n> This release doesn't include features added in v1.4.0-beta.1. They will return in v1.5.0-beta.1.\n\n### Features Added\n* Add `Clone()` method for `arm/policy.ClientOptions`.\n\n### Bugs Fixed\n* ARM's RP registration policy will no longer swallow unrecognized errors.\n* Fixed an issue in `runtime.NewPollerFromResumeToken()` when resuming a `Poller` with a custom `PollingHandler`.\n* Fixed wrong policy copy in `arm/runtime.NewPipeline()`.\n\n## 1.4.0-beta.1 (2023-02-02)\n\n### Features Added\n* Added support for ARM cross-tenant authentication. Set the `AuxiliaryTenants` field of `arm.ClientOptions` to enable.\n* Added `Claims` and `TenantID` fields to `policy.TokenRequestOptions`.\n* ARM bearer token policy handles CAE challenges.\n\n## 1.3.1 (2023-02-02)\n\n### Other Changes\n* Update dependencies to latest versions.\n\n## 1.3.0 (2023-01-06)\n\n### Features Added\n* Added `BearerTokenOptions.AuthorizationHandler` to enable extending `runtime.BearerTokenPolicy`\n with custom authorization logic\n* Added `Client` types and matching constructors to the `azcore` and `arm` packages. These represent a basic client for HTTP and ARM respectively.\n\n### Other Changes\n* Updated `internal` module to latest version.\n* `policy/Request.SetBody()` allows replacing a request's body with an empty one\n\n## 1.2.0 (2022-11-04)\n\n### Features Added\n* Added `ClientOptions.APIVersion` field, which overrides the default version a client\n requests of the service, if the client supports this (all ARM clients do).\n* Added package `tracing` that contains the building blocks for distributed tracing.\n* Added field `TracingProvider` to type `policy.ClientOptions` that will be used to set the per-client tracing implementation.\n\n### Bugs Fixed\n* Fixed an issue in `runtime.SetMultipartFormData` to properly handle slices of `io.ReadSeekCloser`.\n* Fixed the MaxRetryDelay default to be 60s.\n* Failure to poll the state of an LRO will now return an `*azcore.ResponseError` for poller types that require this behavior.\n* Fixed a bug in `runtime.NewPipeline` that would cause pipeline-specified allowed headers and query parameters to be lost.\n\n### Other Changes\n* Retain contents of read-only fields when sending requests.\n\n## 1.1.4 (2022-10-06)\n\n### Bugs Fixed\n* Don't retry a request if the `Retry-After` delay is greater than the configured `RetryOptions.MaxRetryDelay`.\n* `runtime.JoinPaths`: do not unconditionally add a forward slash before the query string\n\n### Other Changes\n* Removed logging URL from retry policy as it's redundant.\n* Retry policy logs when it exits due to a non-retriable status code.\n\n## 1.1.3 (2022-09-01)\n\n### Bugs Fixed\n* Adjusted the initial retry delay to 800ms per the Azure SDK guidelines.\n\n## 1.1.2 (2022-08-09)\n\n### Other Changes\n* Fixed various doc bugs.\n\n## 1.1.1 (2022-06-30)\n\n### Bugs Fixed\n* Avoid polling when a RELO LRO synchronously terminates.\n\n## 1.1.0 (2022-06-03)\n\n### Other Changes\n* The one-second floor for `Frequency` when calling `PollUntilDone()` has been removed when running tests.\n\n## 1.0.0 (2022-05-12)\n\n### Features Added\n* Added interface `runtime.PollingHandler` to support custom poller implementations.\n * Added field `PollingHandler` of this type to `runtime.NewPollerOptions[T]` and `runtime.NewPollerFromResumeTokenOptions[T]`.\n\n### Breaking Changes\n* Renamed `cloud.Configuration.LoginEndpoint` to `.ActiveDirectoryAuthorityHost`\n* Renamed `cloud.AzurePublicCloud` to `cloud.AzurePublic`\n* Removed `AuxiliaryTenants` field from `arm/ClientOptions` and `arm/policy/BearerTokenOptions`\n* Removed `TokenRequestOptions.TenantID`\n* `Poller[T].PollUntilDone()` now takes an `options *PollUntilDoneOptions` param instead of `freq time.Duration`\n* Removed `arm/runtime.Poller[T]`, `arm/runtime.NewPoller[T]()` and `arm/runtime.NewPollerFromResumeToken[T]()`\n* Removed `arm/runtime.FinalStateVia` and related `const` values\n* Renamed `runtime.PageProcessor` to `runtime.PagingHandler`\n* The `arm/runtime.ProviderRepsonse` and `arm/runtime.Provider` types are no longer exported.\n* Renamed `NewRequestIdPolicy()` to `NewRequestIDPolicy()`\n* `TokenCredential.GetToken` now returns `AccessToken` by value.\n\n### Bugs Fixed\n* When per-try timeouts are enabled, only cancel the context after the body has been read and closed.\n* The `Operation-Location` poller now properly handles `final-state-via` values.\n* Improvements in `runtime.Poller[T]`\n * `Poll()` shouldn't cache errors, allowing for additional retries when in a non-terminal state.\n * `Result()` will cache the terminal result or error but not transient errors, allowing for additional retries.\n\n### Other Changes\n* Updated to latest `internal` module and absorbed breaking changes.\n * Use `temporal.Resource` and deleted copy.\n* The internal poller implementation has been refactored.\n * The implementation in `internal/pollers/poller.go` has been merged into `runtime/poller.go` with some slight modification.\n * The internal poller types had their methods updated to conform to the `runtime.PollingHandler` interface.\n * The creation of resume tokens has been refactored so that implementers of `runtime.PollingHandler` don't need to know about it.\n* `NewPipeline()` places policies from `ClientOptions` after policies from `PipelineOptions`\n* Default User-Agent headers no longer include `azcore` version information\n\n## 0.23.1 (2022-04-14)\n\n### Bugs Fixed\n* Include XML header when marshalling XML content.\n* Handle XML namespaces when searching for error code.\n* Handle `odata.error` when searching for error code.\n\n## 0.23.0 (2022-04-04)\n\n### Features Added\n* Added `runtime.Pager[T any]` and `runtime.Poller[T any]` supporting types for central, generic, implementations.\n* Added `cloud` package with a new API for cloud configuration\n* Added `FinalStateVia` field to `runtime.NewPollerOptions[T any]` type.\n\n### Breaking Changes\n* Removed the `Poller` type-alias to the internal poller implementation.\n* Added `Ptr[T any]` and `SliceOfPtrs[T any]` in the `to` package and removed all non-generic implementations.\n* `NullValue` and `IsNullValue` now take a generic type parameter instead of an interface func parameter.\n* Replaced `arm.Endpoint` with `cloud` API\n * Removed the `endpoint` parameter from `NewRPRegistrationPolicy()`\n * `arm/runtime.NewPipeline()` and `.NewRPRegistrationPolicy()` now return an `error`\n* Refactored `NewPoller` and `NewPollerFromResumeToken` funcs in `arm/runtime` and `runtime` packages.\n * Removed the `pollerID` parameter as it's no longer required.\n * Created optional parameter structs and moved optional parameters into them.\n* Changed `FinalStateVia` field to a `const` type.\n\n### Other Changes\n* Converted expiring resource and dependent types to use generics.\n\n## 0.22.0 (2022-03-03)\n\n### Features Added\n* Added header `WWW-Authenticate` to the default allow-list of headers for logging.\n* Added a pipeline policy that enables the retrieval of HTTP responses from API calls.\n * Added `runtime.WithCaptureResponse` to enable the policy at the API level (off by default).\n\n### Breaking Changes\n* Moved `WithHTTPHeader` and `WithRetryOptions` from the `policy` package to the `runtime` package.\n\n## 0.21.1 (2022-02-04)\n\n### Bugs Fixed\n* Restore response body after reading in `Poller.FinalResponse()`. (#16911)\n* Fixed bug in `NullValue` that could lead to incorrect comparisons for empty maps/slices (#16969)\n\n### Other Changes\n* `BearerTokenPolicy` is more resilient to transient authentication failures. (#16789)\n\n## 0.21.0 (2022-01-11)\n\n### Features Added\n* Added `AllowedHeaders` and `AllowedQueryParams` to `policy.LogOptions` to control which headers and query parameters are written to the logger.\n* Added `azcore.ResponseError` type which is returned from APIs when a non-success HTTP status code is received.\n\n### Breaking Changes\n* Moved `[]policy.Policy` parameters of `arm/runtime.NewPipeline` and `runtime.NewPipeline` into a new struct, `runtime.PipelineOptions`\n* Renamed `arm/ClientOptions.Host` to `.Endpoint`\n* Moved `Request.SkipBodyDownload` method to function `runtime.SkipBodyDownload`\n* Removed `azcore.HTTPResponse` interface type\n* `arm.NewPoller()` and `runtime.NewPoller()` no longer require an `eu` parameter\n* `runtime.NewResponseError()` no longer requires an `error` parameter\n\n## 0.20.0 (2021-10-22)\n\n### Breaking Changes\n* Removed `arm.Connection`\n* Removed `azcore.Credential` and `.NewAnonymousCredential()`\n * `NewRPRegistrationPolicy` now requires an `azcore.TokenCredential`\n* `runtime.NewPipeline` has a new signature that simplifies implementing custom authentication\n* `arm/runtime.RegistrationOptions` embeds `policy.ClientOptions`\n* Contents in the `log` package have been slightly renamed.\n* Removed `AuthenticationOptions` in favor of `policy.BearerTokenOptions`\n* Changed parameters for `NewBearerTokenPolicy()`\n* Moved policy config options out of `arm/runtime` and into `arm/policy`\n\n### Features Added\n* Updating Documentation\n* Added string typdef `arm.Endpoint` to provide a hint toward expected ARM client endpoints\n* `azcore.ClientOptions` contains common pipeline configuration settings\n* Added support for multi-tenant authorization in `arm/runtime`\n* Require one second minimum when calling `PollUntilDone()`\n\n### Bug Fixes\n* Fixed a potential panic when creating the default Transporter.\n* Close LRO initial response body when creating a poller.\n* Fixed a panic when recursively cloning structs that contain time.Time.\n\n## 0.19.0 (2021-08-25)\n\n### Breaking Changes\n* Split content out of `azcore` into various packages. The intent is to separate content based on its usage (common, uncommon, SDK authors).\n * `azcore` has all core functionality.\n * `log` contains facilities for configuring in-box logging.\n * `policy` is used for configuring pipeline options and creating custom pipeline policies.\n * `runtime` contains various helpers used by SDK authors and generated content.\n * `streaming` has helpers for streaming IO operations.\n* `NewTelemetryPolicy()` now requires module and version parameters and the `Value` option has been removed.\n * As a result, the `Request.Telemetry()` method has been removed.\n* The telemetry policy now includes the SDK prefix `azsdk-go-` so callers no longer need to provide it.\n* The `*http.Request` in `runtime.Request` is no longer anonymously embedded. Use the `Raw()` method to access it.\n* The `UserAgent` and `Version` constants have been made internal, `Module` and `Version` respectively.\n\n### Bug Fixes\n* Fixed an issue in the retry policy where the request body could be overwritten after a rewind.\n\n### Other Changes\n* Moved modules `armcore` and `to` content into `arm` and `to` packages respectively.\n * The `Pipeline()` method on `armcore.Connection` has been replaced by `NewPipeline()` in `arm.Connection`. It takes module and version parameters used by the telemetry policy.\n* Poller logic has been consolidated across ARM and core implementations.\n * This required some changes to the internal interfaces for core pollers.\n* The core poller types have been improved, including more logging and test coverage.\n\n## 0.18.1 (2021-08-20)\n\n### Features Added\n* Adds an `ETag` type for comparing etags and handling etags on requests\n* Simplifies the `requestBodyProgess` and `responseBodyProgress` into a single `progress` object\n\n### Bugs Fixed\n* `JoinPaths` will preserve query parameters encoded in the `root` url.\n\n### Other Changes\n* Bumps dependency on `internal` module to the latest version (v0.7.0)\n\n## 0.18.0 (2021-07-29)\n### Features Added\n* Replaces methods from Logger type with two package methods for interacting with the logging functionality.\n* `azcore.SetClassifications` replaces `azcore.Logger().SetClassifications`\n* `azcore.SetListener` replaces `azcore.Logger().SetListener`\n\n### Breaking Changes\n* Removes `Logger` type from `azcore`\n\n\n## 0.17.0 (2021-07-27)\n### Features Added\n* Adding TenantID to TokenRequestOptions (https://github.com/Azure/azure-sdk-for-go/pull/14879)\n* Adding AuxiliaryTenants to AuthenticationOptions (https://github.com/Azure/azure-sdk-for-go/pull/15123)\n\n### Breaking Changes\n* Rename `AnonymousCredential` to `NewAnonymousCredential` (https://github.com/Azure/azure-sdk-for-go/pull/15104)\n* rename `AuthenticationPolicyOptions` to `AuthenticationOptions` (https://github.com/Azure/azure-sdk-for-go/pull/15103)\n* Make Header constants private (https://github.com/Azure/azure-sdk-for-go/pull/15038)\n\n\n## 0.16.2 (2021-05-26)\n### Features Added\n* Improved support for byte arrays [#14715](https://github.com/Azure/azure-sdk-for-go/pull/14715)\n\n\n## 0.16.1 (2021-05-19)\n### Features Added\n* Add license.txt to azcore module [#14682](https://github.com/Azure/azure-sdk-for-go/pull/14682)\n\n\n## 0.16.0 (2021-05-07)\n### Features Added\n* Remove extra `*` in UnmarshalAsByteArray() [#14642](https://github.com/Azure/azure-sdk-for-go/pull/14642)\n\n\n## 0.15.1 (2021-05-06)\n### Features Added\n* Cache the original request body on Request [#14634](https://github.com/Azure/azure-sdk-for-go/pull/14634)\n\n\n## 0.15.0 (2021-05-05)\n### Features Added\n* Add support for null map and slice\n* Export `Response.Payload` method\n\n### Breaking Changes\n* remove `Response.UnmarshalError` as it's no longer required\n\n\n## 0.14.5 (2021-04-23)\n### Features Added\n* Add `UnmarshalError()` on `azcore.Response`\n\n\n## 0.14.4 (2021-04-22)\n### Features Added\n* Support for basic LRO polling\n* Added type `LROPoller` and supporting types for basic polling on long running operations.\n* rename poller param and added doc comment\n\n### Bugs Fixed\n* Fixed content type detection bug in logging.\n\n\n## 0.14.3 (2021-03-29)\n### Features Added\n* Add support for multi-part form data\n* Added method `WriteMultipartFormData()` to Request.\n\n\n## 0.14.2 (2021-03-17)\n### Features Added\n* Add support for encoding JSON null values\n* Adds `NullValue()` and `IsNullValue()` functions for setting and detecting sentinel values used for encoding a JSON null.\n* Documentation fixes\n\n### Bugs Fixed\n* Fixed improper error wrapping\n\n\n## 0.14.1 (2021-02-08)\n### Features Added\n* Add `Pager` and `Poller` interfaces to azcore\n\n\n## 0.14.0 (2021-01-12)\n### Features Added\n* Accept zero-value options for default values\n* Specify zero-value options structs to accept default values.\n* Remove `DefaultXxxOptions()` methods.\n* Do not silently change TryTimeout on negative values\n* make per-try timeout opt-in\n\n\n## 0.13.4 (2020-11-20)\n### Features Added\n* Include telemetry string in User Agent\n\n\n## 0.13.3 (2020-11-20)\n### Features Added\n* Updating response body handling on `azcore.Response`\n\n\n## 0.13.2 (2020-11-13)\n### Features Added\n* Remove implementation of stateless policies as first-class functions.\n\n\n## 0.13.1 (2020-11-05)\n### Features Added\n* Add `Telemetry()` method to `azcore.Request()`\n\n\n## 0.13.0 (2020-10-14)\n### Features Added\n* Rename `log` to `logger` to avoid name collision with the log package.\n* Documentation improvements\n* Simplified `DefaultHTTPClientTransport()` implementation\n\n\n## 0.12.1 (2020-10-13)\n### Features Added\n* Update `internal` module dependence to `v0.5.0`\n\n\n## 0.12.0 (2020-10-08)\n### Features Added\n* Removed storage specific content\n* Removed internal content to prevent API clutter\n* Refactored various policy options to conform with our options pattern\n\n\n## 0.11.0 (2020-09-22)\n### Features Added\n\n* Removed `LogError` and `LogSlowResponse`.\n* Renamed `options` in `RequestLogOptions`.\n* Updated `NewRequestLogPolicy()` to follow standard pattern for options.\n* Refactored `requestLogPolicy.Do()` per above changes.\n* Cleaned up/added logging in retry policy.\n* Export `NewResponseError()`\n* Fix `RequestLogOptions` comment\n\n\n## 0.10.1 (2020-09-17)\n### Features Added\n* Add default console logger\n* Default console logger writes to stderr. To enable it, set env var `AZURE_SDK_GO_LOGGING` to the value 'all'.\n* Added `Logger.Writef()` to reduce the need for `ShouldLog()` checks.\n* Add `LogLongRunningOperation`\n\n\n## 0.10.0 (2020-09-10)\n### Features Added\n* The `request` and `transport` interfaces have been refactored to align with the patterns in the standard library.\n* `NewRequest()` now uses `http.NewRequestWithContext()` and performs additional validation, it also requires a context parameter.\n* The `Policy` and `Transport` interfaces have had their context parameter removed as the context is associated with the underlying `http.Request`.\n* `Pipeline.Do()` will validate the HTTP request before sending it through the pipeline, avoiding retries on a malformed request.\n* The `Retrier` interface has been replaced with the `NonRetriableError` interface, and the retry policy updated to test for this.\n* `Request.SetBody()` now requires a content type parameter for setting the request's MIME type.\n* moved path concatenation into `JoinPaths()` func\n\n\n## 0.9.6 (2020-08-18)\n### Features Added\n* Improvements to body download policy\n* Always download the response body for error responses, i.e. HTTP status codes >= 400.\n* Simplify variable declarations\n\n\n## 0.9.5 (2020-08-11)\n### Features Added\n* Set the Content-Length header in `Request.SetBody`\n\n\n## 0.9.4 (2020-08-03)\n### Features Added\n* Fix cancellation of per try timeout\n* Per try timeout is used to ensure that an HTTP operation doesn't take too long, e.g. that a GET on some URL doesn't take an inordinant amount of time.\n* Once the HTTP request returns, the per try timeout should be cancelled, not when the response has been read to completion.\n* Do not drain response body if there are no more retries\n* Do not retry non-idempotent operations when body download fails\n\n\n## 0.9.3 (2020-07-28)\n### Features Added\n* Add support for custom HTTP request headers\n* Inserts an internal policy into the pipeline that can extract HTTP header values from the caller's context, adding them to the request.\n* Use `azcore.WithHTTPHeader` to add HTTP headers to a context.\n* Remove method specific to Go 1.14\n\n\n## 0.9.2 (2020-07-28)\n### Features Added\n* Omit read-only content from request payloads\n* If any field in a payload's object graph contains `azure:\"ro\"`, make a clone of the object graph, omitting all fields with this annotation.\n* Verify no fields were dropped\n* Handle embedded struct types\n* Added test for cloning by value\n* Add messages to failures\n\n\n## 0.9.1 (2020-07-22)\n### Features Added\n* Updated dependency on internal module to fix race condition.\n\n\n## 0.9.0 (2020-07-09)\n### Features Added\n* Add `HTTPResponse` interface to be used by callers to access the raw HTTP response from an error in the event of an API call failure.\n* Updated `sdk/internal` dependency to latest version.\n* Rename package alias\n\n\n## 0.8.2 (2020-06-29)\n### Features Added\n* Added missing documentation comments\n\n### Bugs Fixed\n* Fixed a bug in body download policy.\n\n\n## 0.8.1 (2020-06-26)\n### Features Added\n* Miscellaneous clean-up reported by linters\n\n\n## 0.8.0 (2020-06-01)\n### Features Added\n* Differentiate between standard and URL encoding.\n\n\n## 0.7.1 (2020-05-27)\n### Features Added\n* Add support for for base64 encoding and decoding of payloads.\n\n\n## 0.7.0 (2020-05-12)\n### Features Added\n* Change `RetryAfter()` to a function.\n\n\n## 0.6.0 (2020-04-29)\n### Features Added\n* Updating `RetryAfter` to only return the detaion in the RetryAfter header\n\n\n## 0.5.0 (2020-03-23)\n### Features Added\n* Export `TransportFunc`\n\n### Breaking Changes\n* Removed `IterationDone`\n\n\n## 0.4.1 (2020-02-25)\n### Features Added\n* Ensure per-try timeout is properly cancelled\n* Explicitly call cancel the per-try timeout when the response body has been read/closed by the body download policy.\n* When the response body is returned to the caller for reading/closing, wrap it in a `responseBodyReader` that will cancel the timeout when the body is closed.\n* `Logger.Should()` will return false if no listener is set.\n\n\n## 0.4.0 (2020-02-18)\n### Features Added\n* Enable custom `RetryOptions` to be specified per API call\n* Added `WithRetryOptions()` that adds a custom `RetryOptions` to the provided context, allowing custom settings per API call.\n* Remove 429 from the list of default HTTP status codes for retry.\n* Change StatusCodesForRetry to a slice so consumers can append to it.\n* Added support for retry-after in HTTP-date format.\n* Cleaned up some comments specific to storage.\n* Remove `Request.SetQueryParam()`\n* Renamed `MaxTries` to `MaxRetries`\n\n## 0.3.0 (2020-01-16)\n### Features Added\n* Added `DefaultRetryOptions` to create initialized default options.\n\n### Breaking Changes\n* Removed `Response.CheckStatusCode()`\n\n\n## 0.2.0 (2020-01-15)\n### Features Added\n* Add support for marshalling and unmarshalling JSON\n* Removed `Response.Payload` field\n* Exit early when unmarsahlling if there is no payload\n\n\n## 0.1.0 (2020-01-10)\n### Features Added\n* Initial release\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/LICENSE.txt",
"content": "MIT License\n\nCopyright (c) Microsoft Corporation.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/README.md",
"content": "# Azure Core Client Module for Go\n\n[](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore)\n[](https://dev.azure.com/azure-sdk/public/_build/latest?definitionId=1843&branchName=main)\n[](https://img.shields.io/azure-devops/coverage/azure-sdk/public/1843/main)\n\nThe `azcore` module provides a set of common interfaces and types for Go SDK client modules.\nThese modules follow the [Azure SDK Design Guidelines for Go](https://azure.github.io/azure-sdk/golang_introduction.html).\n\n## Getting started\n\nThis project uses [Go modules](https://github.com/golang/go/wiki/Modules) for versioning and dependency management.\n\nTypically, you will not need to explicitly install `azcore` as it will be installed as a client module dependency.\nTo add the latest version to your `go.mod` file, execute the following command.\n\n```bash\ngo get github.com/Azure/azure-sdk-for-go/sdk/azcore\n```\n\nGeneral documentation and examples can be found on [pkg.go.dev](https://pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore).\n\n## Contributing\nThis project welcomes contributions and suggestions. Most contributions require\nyou to agree to a Contributor License Agreement (CLA) declaring that you have\nthe right to, and actually do, grant us the rights to use your contribution.\nFor details, visit [https://cla.microsoft.com](https://cla.microsoft.com).\n\nWhen you submit a pull request, a CLA-bot will automatically determine whether\nyou need to provide a CLA and decorate the PR appropriately (e.g., label,\ncomment). Simply follow the instructions provided by the bot. You will only\nneed to do this once across all repos using our CLA.\n\nThis project has adopted the\n[Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).\nFor more information, see the\n[Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)\nor contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any\nadditional questions or comments.\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/ci.yml",
"content": "# NOTE: Please refer to https://aka.ms/azsdk/engsys/ci-yaml before editing this file.\ntrigger:\n branches:\n include:\n - main\n - feature/*\n - hotfix/*\n - release/*\n paths:\n include:\n - sdk/azcore/\n - eng/\n\npr:\n branches:\n include:\n - main\n - feature/*\n - hotfix/*\n - release/*\n paths:\n include:\n - sdk/azcore/\n - eng/\n\nextends:\n template: /eng/pipelines/templates/jobs/archetype-sdk-client.yml\n parameters:\n ServiceDirectory: azcore\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/cloud/cloud.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage cloud\n\nvar (\n\t// AzureChina contains configuration for Azure China.\n\tAzureChina = Configuration{\n\t\tActiveDirectoryAuthorityHost: \"https://login.chinacloudapi.cn/\", Services: map[ServiceName]ServiceConfiguration{},\n\t}\n\t// AzureGovernment contains configuration for Azure Government.\n\tAzureGovernment = Configuration{\n\t\tActiveDirectoryAuthorityHost: \"https://login.microsoftonline.us/\", Services: map[ServiceName]ServiceConfiguration{},\n\t}\n\t// AzurePublic contains configuration for Azure Public Cloud.\n\tAzurePublic = Configuration{\n\t\tActiveDirectoryAuthorityHost: \"https://login.microsoftonline.com/\", Services: map[ServiceName]ServiceConfiguration{},\n\t}\n)\n\n// ServiceName identifies a cloud service.\ntype ServiceName string\n\n// ResourceManager is a global constant identifying Azure Resource Manager.\nconst ResourceManager ServiceName = \"resourceManager\"\n\n// ServiceConfiguration configures a specific cloud service such as Azure Resource Manager.\ntype ServiceConfiguration struct {\n\t// Audience is the audience the client will request for its access tokens.\n\tAudience string\n\t// Endpoint is the service's base URL.\n\tEndpoint string\n}\n\n// Configuration configures a cloud.\ntype Configuration struct {\n\t// ActiveDirectoryAuthorityHost is the base URL of the cloud's Azure Active Directory.\n\tActiveDirectoryAuthorityHost string\n\t// Services contains configuration for the cloud's services.\n\tServices map[ServiceName]ServiceConfiguration\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/cloud/doc.go",
"content": "//go:build go1.16\n// +build go1.16\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/*\nPackage cloud implements a configuration API for applications deployed to sovereign or private Azure clouds.\n\nAzure SDK client configuration defaults are appropriate for Azure Public Cloud (sometimes referred to as\n\"Azure Commercial\" or simply \"Microsoft Azure\"). This package enables applications deployed to other\nAzure Clouds to configure clients appropriately.\n\nThis package contains predefined configuration for well-known sovereign clouds such as Azure Government and\nAzure China. Azure SDK clients accept this configuration via the Cloud field of azcore.ClientOptions. For\nexample, configuring a credential and ARM client for Azure Government:\n\n\topts := azcore.ClientOptions{Cloud: cloud.AzureGovernment}\n\tcred, err := azidentity.NewDefaultAzureCredential(\n\t\t&azidentity.DefaultAzureCredentialOptions{ClientOptions: opts},\n\t)\n\thandle(err)\n\n\tclient, err := armsubscription.NewClient(\n\t\tcred, &arm.ClientOptions{ClientOptions: opts},\n\t)\n\thandle(err)\n\nApplications deployed to a private cloud such as Azure Stack create a Configuration object with\nappropriate values:\n\n\tc := cloud.Configuration{\n\t\tActiveDirectoryAuthorityHost: \"https://...\",\n\t\tServices: map[cloud.ServiceName]cloud.ServiceConfiguration{\n\t\t\tcloud.ResourceManager: {\n\t\t\t\tAudience: \"...\",\n\t\t\t\tEndpoint: \"https://...\",\n\t\t\t},\n\t\t},\n\t}\n\topts := azcore.ClientOptions{Cloud: c}\n\n\tcred, err := azidentity.NewDefaultAzureCredential(\n\t\t&azidentity.DefaultAzureCredentialOptions{ClientOptions: opts},\n\t)\n\thandle(err)\n\n\tclient, err := armsubscription.NewClient(\n\t\tcred, &arm.ClientOptions{ClientOptions: opts},\n\t)\n\thandle(err)\n*/\npackage cloud\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/core.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage azcore\n\nimport (\n\t\"reflect\"\n\t\"sync\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/tracing\"\n)\n\n// AccessToken represents an Azure service bearer access token with expiry information.\ntype AccessToken = exported.AccessToken\n\n// TokenCredential represents a credential capable of providing an OAuth token.\ntype TokenCredential = exported.TokenCredential\n\n// KeyCredential contains an authentication key used to authenticate to an Azure service.\ntype KeyCredential = exported.KeyCredential\n\n// NewKeyCredential creates a new instance of [KeyCredential] with the specified values.\n// - key is the authentication key\nfunc NewKeyCredential(key string) *KeyCredential {\n\treturn exported.NewKeyCredential(key)\n}\n\n// SASCredential contains a shared access signature used to authenticate to an Azure service.\ntype SASCredential = exported.SASCredential\n\n// NewSASCredential creates a new instance of [SASCredential] with the specified values.\n// - sas is the shared access signature\nfunc NewSASCredential(sas string) *SASCredential {\n\treturn exported.NewSASCredential(sas)\n}\n\n// holds sentinel values used to send nulls\nvar nullables map[reflect.Type]any = map[reflect.Type]any{}\nvar nullablesMu sync.RWMutex\n\n// NullValue is used to send an explicit 'null' within a request.\n// This is typically used in JSON-MERGE-PATCH operations to delete a value.\nfunc NullValue[T any]() T {\n\tt := shared.TypeOfT[T]()\n\n\tnullablesMu.RLock()\n\tv, found := nullables[t]\n\tnullablesMu.RUnlock()\n\n\tif found {\n\t\t// return the sentinel object\n\t\treturn v.(T)\n\t}\n\n\t// promote to exclusive lock and check again (double-checked locking pattern)\n\tnullablesMu.Lock()\n\tdefer nullablesMu.Unlock()\n\tv, found = nullables[t]\n\n\tif !found {\n\t\tvar o reflect.Value\n\t\tif k := t.Kind(); k == reflect.Map {\n\t\t\to = reflect.MakeMap(t)\n\t\t} else if k == reflect.Slice {\n\t\t\t// empty slices appear to all point to the same data block\n\t\t\t// which causes comparisons to become ambiguous. so we create\n\t\t\t// a slice with len/cap of one which ensures a unique address.\n\t\t\to = reflect.MakeSlice(t, 1, 1)\n\t\t} else {\n\t\t\to = reflect.New(t.Elem())\n\t\t}\n\t\tv = o.Interface()\n\t\tnullables[t] = v\n\t}\n\t// return the sentinel object\n\treturn v.(T)\n}\n\n// IsNullValue returns true if the field contains a null sentinel value.\n// This is used by custom marshallers to properly encode a null value.\nfunc IsNullValue[T any](v T) bool {\n\t// see if our map has a sentinel object for this *T\n\tt := reflect.TypeOf(v)\n\tnullablesMu.RLock()\n\tdefer nullablesMu.RUnlock()\n\n\tif o, found := nullables[t]; found {\n\t\to1 := reflect.ValueOf(o)\n\t\tv1 := reflect.ValueOf(v)\n\t\t// we found it; return true if v points to the sentinel object.\n\t\t// NOTE: maps and slices can only be compared to nil, else you get\n\t\t// a runtime panic. so we compare addresses instead.\n\t\treturn o1.Pointer() == v1.Pointer()\n\t}\n\t// no sentinel object for this *t\n\treturn false\n}\n\n// ClientOptions contains optional settings for a client's pipeline.\n// Instances can be shared across calls to SDK client constructors when uniform configuration is desired.\n// Zero-value fields will have their specified default values applied during use.\ntype ClientOptions = policy.ClientOptions\n\n// Client is a basic HTTP client. It consists of a pipeline and tracing provider.\ntype Client struct {\n\tpl runtime.Pipeline\n\ttr tracing.Tracer\n\n\t// cached on the client to support shallow copying with new values\n\ttp tracing.Provider\n\tmodVer string\n\tnamespace string\n}\n\n// NewClient creates a new Client instance with the provided values.\n// - moduleName - the fully qualified name of the module where the client is defined; used by the telemetry policy and tracing provider.\n// - moduleVersion - the semantic version of the module; used by the telemetry policy and tracing provider.\n// - plOpts - pipeline configuration options; can be the zero-value\n// - options - optional client configurations; pass nil to accept the default values\nfunc NewClient(moduleName, moduleVersion string, plOpts runtime.PipelineOptions, options *ClientOptions) (*Client, error) {\n\tif options == nil {\n\t\toptions = &ClientOptions{}\n\t}\n\n\tif !options.Telemetry.Disabled {\n\t\tif err := shared.ValidateModVer(moduleVersion); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\n\tpl := runtime.NewPipeline(moduleName, moduleVersion, plOpts, options)\n\n\ttr := options.TracingProvider.NewTracer(moduleName, moduleVersion)\n\tif tr.Enabled() && plOpts.Tracing.Namespace != \"\" {\n\t\ttr.SetAttributes(tracing.Attribute{Key: shared.TracingNamespaceAttrName, Value: plOpts.Tracing.Namespace})\n\t}\n\n\treturn &Client{\n\t\tpl: pl,\n\t\ttr: tr,\n\t\ttp: options.TracingProvider,\n\t\tmodVer: moduleVersion,\n\t\tnamespace: plOpts.Tracing.Namespace,\n\t}, nil\n}\n\n// Pipeline returns the pipeline for this client.\nfunc (c *Client) Pipeline() runtime.Pipeline {\n\treturn c.pl\n}\n\n// Tracer returns the tracer for this client.\nfunc (c *Client) Tracer() tracing.Tracer {\n\treturn c.tr\n}\n\n// WithClientName returns a shallow copy of the Client with its tracing client name changed to clientName.\n// Note that the values for module name and version will be preserved from the source Client.\n// - clientName - the fully qualified name of the client (\"package.Client\"); this is used by the tracing provider when creating spans\nfunc (c *Client) WithClientName(clientName string) *Client {\n\ttr := c.tp.NewTracer(clientName, c.modVer)\n\tif tr.Enabled() && c.namespace != \"\" {\n\t\ttr.SetAttributes(tracing.Attribute{Key: shared.TracingNamespaceAttrName, Value: c.namespace})\n\t}\n\treturn &Client{pl: c.pl, tr: tr, tp: c.tp, modVer: c.modVer, namespace: c.namespace}\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/doc.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright 2017 Microsoft Corporation. All rights reserved.\n// Use of this source code is governed by an MIT\n// license that can be found in the LICENSE file.\n\n/*\nPackage azcore implements an HTTP request/response middleware pipeline used by Azure SDK clients.\n\nThe middleware consists of three components.\n\n - One or more Policy instances.\n - A Transporter instance.\n - A Pipeline instance that combines the Policy and Transporter instances.\n\n# Implementing the Policy Interface\n\nA Policy can be implemented in two ways; as a first-class function for a stateless Policy, or as\na method on a type for a stateful Policy. Note that HTTP requests made via the same pipeline share\nthe same Policy instances, so if a Policy mutates its state it MUST be properly synchronized to\navoid race conditions.\n\nA Policy's Do method is called when an HTTP request wants to be sent over the network. The Do method can\nperform any operation(s) it desires. For example, it can log the outgoing request, mutate the URL, headers,\nand/or query parameters, inject a failure, etc. Once the Policy has successfully completed its request\nwork, it must call the Next() method on the *policy.Request instance in order to pass the request to the\nnext Policy in the chain.\n\nWhen an HTTP response comes back, the Policy then gets a chance to process the response/error. The Policy instance\ncan log the response, retry the operation if it failed due to a transient error or timeout, unmarshal the response\nbody, etc. Once the Policy has successfully completed its response work, it must return the *http.Response\nand error instances to its caller.\n\nTemplate for implementing a stateless Policy:\n\n\ttype policyFunc func(*policy.Request) (*http.Response, error)\n\n\t// Do implements the Policy interface on policyFunc.\n\tfunc (pf policyFunc) Do(req *policy.Request) (*http.Response, error) {\n\t\treturn pf(req)\n\t}\n\n\tfunc NewMyStatelessPolicy() policy.Policy {\n\t\treturn policyFunc(func(req *policy.Request) (*http.Response, error) {\n\t\t\t// TODO: mutate/process Request here\n\n\t\t\t// forward Request to next Policy & get Response/error\n\t\t\tresp, err := req.Next()\n\n\t\t\t// TODO: mutate/process Response/error here\n\n\t\t\t// return Response/error to previous Policy\n\t\t\treturn resp, err\n\t\t})\n\t}\n\nTemplate for implementing a stateful Policy:\n\n\ttype MyStatefulPolicy struct {\n\t\t// TODO: add configuration/setting fields here\n\t}\n\n\t// TODO: add initialization args to NewMyStatefulPolicy()\n\tfunc NewMyStatefulPolicy() policy.Policy {\n\t\treturn &MyStatefulPolicy{\n\t\t\t// TODO: initialize configuration/setting fields here\n\t\t}\n\t}\n\n\tfunc (p *MyStatefulPolicy) Do(req *policy.Request) (resp *http.Response, err error) {\n\t\t// TODO: mutate/process Request here\n\n\t\t// forward Request to next Policy & get Response/error\n\t\tresp, err := req.Next()\n\n\t\t// TODO: mutate/process Response/error here\n\n\t\t// return Response/error to previous Policy\n\t\treturn resp, err\n\t}\n\n# Implementing the Transporter Interface\n\nThe Transporter interface is responsible for sending the HTTP request and returning the corresponding\nHTTP response or error. The Transporter is invoked by the last Policy in the chain. The default Transporter\nimplementation uses a shared http.Client from the standard library.\n\nThe same stateful/stateless rules for Policy implementations apply to Transporter implementations.\n\n# Using Policy and Transporter Instances Via a Pipeline\n\nTo use the Policy and Transporter instances, an application passes them to the runtime.NewPipeline function.\n\n\tfunc NewPipeline(transport Transporter, policies ...Policy) Pipeline\n\nThe specified Policy instances form a chain and are invoked in the order provided to NewPipeline\nfollowed by the Transporter.\n\nOnce the Pipeline has been created, create a runtime.Request instance and pass it to Pipeline's Do method.\n\n\tfunc NewRequest(ctx context.Context, httpMethod string, endpoint string) (*Request, error)\n\n\tfunc (p Pipeline) Do(req *Request) (*http.Request, error)\n\nThe Pipeline.Do method sends the specified Request through the chain of Policy and Transporter\ninstances. The response/error is then sent through the same chain of Policy instances in reverse\norder. For example, assuming there are Policy types PolicyA, PolicyB, and PolicyC along with\nTransportA.\n\n\tpipeline := NewPipeline(TransportA, PolicyA, PolicyB, PolicyC)\n\nThe flow of Request and Response looks like the following:\n\n\tpolicy.Request -> PolicyA -> PolicyB -> PolicyC -> TransportA -----+\n\t |\n\t HTTP(S) endpoint\n\t |\n\tcaller <--------- PolicyA <- PolicyB <- PolicyC <- http.Response-+\n\n# Creating a Request Instance\n\nThe Request instance passed to Pipeline's Do method is a wrapper around an *http.Request. It also\ncontains some internal state and provides various convenience methods. You create a Request instance\nby calling the runtime.NewRequest function:\n\n\tfunc NewRequest(ctx context.Context, httpMethod string, endpoint string) (*Request, error)\n\nIf the Request should contain a body, call the SetBody method.\n\n\tfunc (req *Request) SetBody(body ReadSeekCloser, contentType string) error\n\nA seekable stream is required so that upon retry, the retry Policy instance can seek the stream\nback to the beginning before retrying the network request and re-uploading the body.\n\n# Sending an Explicit Null\n\nOperations like JSON-MERGE-PATCH send a JSON null to indicate a value should be deleted.\n\n\t{\n\t\t\"delete-me\": null\n\t}\n\nThis requirement conflicts with the SDK's default marshalling that specifies \"omitempty\" as\na means to resolve the ambiguity between a field to be excluded and its zero-value.\n\n\ttype Widget struct {\n\t\tName *string `json:\",omitempty\"`\n\t\tCount *int `json:\",omitempty\"`\n\t}\n\nIn the above example, Name and Count are defined as pointer-to-type to disambiguate between\na missing value (nil) and a zero-value (0) which might have semantic differences.\n\nIn a PATCH operation, any fields left as nil are to have their values preserved. When updating\na Widget's count, one simply specifies the new value for Count, leaving Name nil.\n\nTo fulfill the requirement for sending a JSON null, the NullValue() function can be used.\n\n\tw := Widget{\n\t\tCount: azcore.NullValue[*int](),\n\t}\n\nThis sends an explict \"null\" for Count, indicating that any current value for Count should be deleted.\n\n# Processing the Response\n\nWhen the HTTP response is received, the *http.Response is returned directly. Each Policy instance\ncan inspect/mutate the *http.Response.\n\n# Built-in Logging\n\nTo enable logging, set environment variable AZURE_SDK_GO_LOGGING to \"all\" before executing your program.\n\nBy default the logger writes to stderr. This can be customized by calling log.SetListener, providing\na callback that writes to the desired location. Any custom logging implementation MUST provide its\nown synchronization to handle concurrent invocations.\n\nSee the docs for the log package for further details.\n\n# Pageable Operations\n\nPageable operations return potentially large data sets spread over multiple GET requests. The result of\neach GET is a \"page\" of data consisting of a slice of items.\n\nPageable operations can be identified by their New*Pager naming convention and return type of *runtime.Pager[T].\n\n\tfunc (c *WidgetClient) NewListWidgetsPager(o *Options) *runtime.Pager[PageResponse]\n\nThe call to WidgetClient.NewListWidgetsPager() returns an instance of *runtime.Pager[T] for fetching pages\nand determining if there are more pages to fetch. No IO calls are made until the NextPage() method is invoked.\n\n\tpager := widgetClient.NewListWidgetsPager(nil)\n\tfor pager.More() {\n\t\tpage, err := pager.NextPage(context.TODO())\n\t\t// handle err\n\t\tfor _, widget := range page.Values {\n\t\t\t// process widget\n\t\t}\n\t}\n\n# Long-Running Operations\n\nLong-running operations (LROs) are operations consisting of an initial request to start the operation followed\nby polling to determine when the operation has reached a terminal state. An LRO's terminal state is one\nof the following values.\n\n - Succeeded - the LRO completed successfully\n - Failed - the LRO failed to complete\n - Canceled - the LRO was canceled\n\nLROs can be identified by their Begin* prefix and their return type of *runtime.Poller[T].\n\n\tfunc (c *WidgetClient) BeginCreateOrUpdate(ctx context.Context, w Widget, o *Options) (*runtime.Poller[Response], error)\n\nWhen a call to WidgetClient.BeginCreateOrUpdate() returns a nil error, it means that the LRO has started.\nIt does _not_ mean that the widget has been created or updated (or failed to be created/updated).\n\nThe *runtime.Poller[T] provides APIs for determining the state of the LRO. To wait for the LRO to complete,\ncall the PollUntilDone() method.\n\n\tpoller, err := widgetClient.BeginCreateOrUpdate(context.TODO(), Widget{}, nil)\n\t// handle err\n\tresult, err := poller.PollUntilDone(context.TODO(), nil)\n\t// handle err\n\t// use result\n\nThe call to PollUntilDone() will block the current goroutine until the LRO has reached a terminal state or the\ncontext is canceled/timed out.\n\nNote that LROs can take anywhere from several seconds to several minutes. The duration is operation-dependent. Due to\nthis variant behavior, pollers do _not_ have a preconfigured time-out. Use a context with the appropriate cancellation\nmechanism as required.\n\n# Resume Tokens\n\nPollers provide the ability to serialize their state into a \"resume token\" which can be used by another process to\nrecreate the poller. This is achieved via the runtime.Poller[T].ResumeToken() method.\n\n\ttoken, err := poller.ResumeToken()\n\t// handle error\n\nNote that a token can only be obtained for a poller that's in a non-terminal state. Also note that any subsequent calls\nto poller.Poll() might change the poller's state. In this case, a new token should be created.\n\nAfter the token has been obtained, it can be used to recreate an instance of the originating poller.\n\n\tpoller, err := widgetClient.BeginCreateOrUpdate(nil, Widget{}, &Options{\n\t\tResumeToken: token,\n\t})\n\nWhen resuming a poller, no IO is performed, and zero-value arguments can be used for everything but the Options.ResumeToken.\n\nResume tokens are unique per service client and operation. Attempting to resume a poller for LRO BeginB() with a token from LRO\nBeginA() will result in an error.\n\n# Fakes\n\nThe fake package contains types used for constructing in-memory fake servers used in unit tests.\nThis allows writing tests to cover various success/error conditions without the need for connecting to a live service.\n\nPlease see https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/samples/fakes for details and examples on how to use fakes.\n*/\npackage azcore\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/errors.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage azcore\n\nimport \"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported\"\n\n// ResponseError is returned when a request is made to a service and\n// the service returns a non-success HTTP status code.\n// Use errors.As() to access this type in the error chain.\n//\n// When marshaling instances, the RawResponse field will be omitted.\n// However, the contents returned by Error() will be preserved.\ntype ResponseError = exported.ResponseError\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/etag.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage azcore\n\nimport (\n\t\"strings\"\n)\n\n// ETag is a property used for optimistic concurrency during updates\n// ETag is a validator based on https://tools.ietf.org/html/rfc7232#section-2.3.2\n// An ETag can be empty (\"\").\ntype ETag string\n\n// ETagAny is an ETag that represents everything, the value is \"*\"\nconst ETagAny ETag = \"*\"\n\n// Equals does a strong comparison of two ETags. Equals returns true when both\n// ETags are not weak and the values of the underlying strings are equal.\nfunc (e ETag) Equals(other ETag) bool {\n\treturn !e.IsWeak() && !other.IsWeak() && e == other\n}\n\n// WeakEquals does a weak comparison of two ETags. Two ETags are equivalent if their opaque-tags match\n// character-by-character, regardless of either or both being tagged as \"weak\".\nfunc (e ETag) WeakEquals(other ETag) bool {\n\tgetStart := func(e1 ETag) int {\n\t\tif e1.IsWeak() {\n\t\t\treturn 2\n\t\t}\n\t\treturn 0\n\t}\n\taStart := getStart(e)\n\tbStart := getStart(other)\n\n\taVal := e[aStart:]\n\tbVal := other[bStart:]\n\n\treturn aVal == bVal\n}\n\n// IsWeak specifies whether the ETag is strong or weak.\nfunc (e ETag) IsWeak() bool {\n\treturn len(e) >= 4 && strings.HasPrefix(string(e), \"W/\\\"\") && strings.HasSuffix(string(e), \"\\\"\")\n}\n\n// MatchConditions specifies HTTP options for conditional requests.\ntype MatchConditions struct {\n\t// Optionally limit requests to resources that have a matching ETag.\n\tIfMatch *ETag\n\n\t// Optionally limit requests to resources that do not match the ETag.\n\tIfNoneMatch *ETag\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported/exported.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage exported\n\nimport (\n\t\"context\"\n\t\"encoding/base64\"\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n\t\"sync/atomic\"\n\t\"time\"\n)\n\ntype nopCloser struct {\n\tio.ReadSeeker\n}\n\nfunc (n nopCloser) Close() error {\n\treturn nil\n}\n\n// NopCloser returns a ReadSeekCloser with a no-op close method wrapping the provided io.ReadSeeker.\n// Exported as streaming.NopCloser().\nfunc NopCloser(rs io.ReadSeeker) io.ReadSeekCloser {\n\treturn nopCloser{rs}\n}\n\n// HasStatusCode returns true if the Response's status code is one of the specified values.\n// Exported as runtime.HasStatusCode().\nfunc HasStatusCode(resp *http.Response, statusCodes ...int) bool {\n\tif resp == nil {\n\t\treturn false\n\t}\n\tfor _, sc := range statusCodes {\n\t\tif resp.StatusCode == sc {\n\t\t\treturn true\n\t\t}\n\t}\n\treturn false\n}\n\n// AccessToken represents an Azure service bearer access token with expiry information.\n// Exported as azcore.AccessToken.\ntype AccessToken struct {\n\t// Token is the access token\n\tToken string\n\t// ExpiresOn indicates when the token expires\n\tExpiresOn time.Time\n\t// RefreshOn is a suggested time to refresh the token.\n\t// Clients should ignore this value when it's zero.\n\tRefreshOn time.Time\n}\n\n// TokenRequestOptions contain specific parameter that may be used by credentials types when attempting to get a token.\n// Exported as policy.TokenRequestOptions.\ntype TokenRequestOptions struct {\n\t// Claims are any additional claims required for the token to satisfy a conditional access policy, such as a\n\t// service may return in a claims challenge following an authorization failure. If a service returned the\n\t// claims value base64 encoded, it must be decoded before setting this field.\n\tClaims string\n\n\t// EnableCAE indicates whether to enable Continuous Access Evaluation (CAE) for the requested token. When true,\n\t// azidentity credentials request CAE tokens for resource APIs supporting CAE. Clients are responsible for\n\t// handling CAE challenges. If a client that doesn't handle CAE challenges receives a CAE token, it may end up\n\t// in a loop retrying an API call with a token that has been revoked due to CAE.\n\tEnableCAE bool\n\n\t// Scopes contains the list of permission scopes required for the token.\n\tScopes []string\n\n\t// TenantID identifies the tenant from which to request the token. azidentity credentials authenticate in\n\t// their configured default tenants when this field isn't set.\n\tTenantID string\n}\n\n// TokenCredential represents a credential capable of providing an OAuth token.\n// Exported as azcore.TokenCredential.\ntype TokenCredential interface {\n\t// GetToken requests an access token for the specified set of scopes.\n\tGetToken(ctx context.Context, options TokenRequestOptions) (AccessToken, error)\n}\n\n// DecodeByteArray will base-64 decode the provided string into v.\n// Exported as runtime.DecodeByteArray()\nfunc DecodeByteArray(s string, v *[]byte, format Base64Encoding) error {\n\tif len(s) == 0 {\n\t\treturn nil\n\t}\n\tpayload := string(s)\n\tif payload[0] == '\"' {\n\t\t// remove surrounding quotes\n\t\tpayload = payload[1 : len(payload)-1]\n\t}\n\tswitch format {\n\tcase Base64StdFormat:\n\t\tdecoded, err := base64.StdEncoding.DecodeString(payload)\n\t\tif err == nil {\n\t\t\t*v = decoded\n\t\t\treturn nil\n\t\t}\n\t\treturn err\n\tcase Base64URLFormat:\n\t\t// use raw encoding as URL format should not contain any '=' characters\n\t\tdecoded, err := base64.RawURLEncoding.DecodeString(payload)\n\t\tif err == nil {\n\t\t\t*v = decoded\n\t\t\treturn nil\n\t\t}\n\t\treturn err\n\tdefault:\n\t\treturn fmt.Errorf(\"unrecognized byte array format: %d\", format)\n\t}\n}\n\n// KeyCredential contains an authentication key used to authenticate to an Azure service.\n// Exported as azcore.KeyCredential.\ntype KeyCredential struct {\n\tcred *keyCredential\n}\n\n// NewKeyCredential creates a new instance of [KeyCredential] with the specified values.\n// - key is the authentication key\nfunc NewKeyCredential(key string) *KeyCredential {\n\treturn &KeyCredential{cred: newKeyCredential(key)}\n}\n\n// Update replaces the existing key with the specified value.\nfunc (k *KeyCredential) Update(key string) {\n\tk.cred.Update(key)\n}\n\n// SASCredential contains a shared access signature used to authenticate to an Azure service.\n// Exported as azcore.SASCredential.\ntype SASCredential struct {\n\tcred *keyCredential\n}\n\n// NewSASCredential creates a new instance of [SASCredential] with the specified values.\n// - sas is the shared access signature\nfunc NewSASCredential(sas string) *SASCredential {\n\treturn &SASCredential{cred: newKeyCredential(sas)}\n}\n\n// Update replaces the existing shared access signature with the specified value.\nfunc (k *SASCredential) Update(sas string) {\n\tk.cred.Update(sas)\n}\n\n// KeyCredentialGet returns the key for cred.\nfunc KeyCredentialGet(cred *KeyCredential) string {\n\treturn cred.cred.Get()\n}\n\n// SASCredentialGet returns the shared access sig for cred.\nfunc SASCredentialGet(cred *SASCredential) string {\n\treturn cred.cred.Get()\n}\n\ntype keyCredential struct {\n\tkey atomic.Value // string\n}\n\nfunc newKeyCredential(key string) *keyCredential {\n\tkeyCred := keyCredential{}\n\tkeyCred.key.Store(key)\n\treturn &keyCred\n}\n\nfunc (k *keyCredential) Get() string {\n\treturn k.key.Load().(string)\n}\n\nfunc (k *keyCredential) Update(key string) {\n\tk.key.Store(key)\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported/pipeline.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage exported\n\nimport (\n\t\"errors\"\n\t\"net/http\"\n)\n\n// Policy represents an extensibility point for the Pipeline that can mutate the specified\n// Request and react to the received Response.\n// Exported as policy.Policy.\ntype Policy interface {\n\t// Do applies the policy to the specified Request. When implementing a Policy, mutate the\n\t// request before calling req.Next() to move on to the next policy, and respond to the result\n\t// before returning to the caller.\n\tDo(req *Request) (*http.Response, error)\n}\n\n// Pipeline represents a primitive for sending HTTP requests and receiving responses.\n// Its behavior can be extended by specifying policies during construction.\n// Exported as runtime.Pipeline.\ntype Pipeline struct {\n\tpolicies []Policy\n}\n\n// Transporter represents an HTTP pipeline transport used to send HTTP requests and receive responses.\n// Exported as policy.Transporter.\ntype Transporter interface {\n\t// Do sends the HTTP request and returns the HTTP response or error.\n\tDo(req *http.Request) (*http.Response, error)\n}\n\n// used to adapt a TransportPolicy to a Policy\ntype transportPolicy struct {\n\ttrans Transporter\n}\n\nfunc (tp transportPolicy) Do(req *Request) (*http.Response, error) {\n\tif tp.trans == nil {\n\t\treturn nil, errors.New(\"missing transporter\")\n\t}\n\tresp, err := tp.trans.Do(req.Raw())\n\tif err != nil {\n\t\treturn nil, err\n\t} else if resp == nil {\n\t\t// there was no response and no error (rare but can happen)\n\t\t// this ensures the retry policy will retry the request\n\t\treturn nil, errors.New(\"received nil response\")\n\t}\n\treturn resp, nil\n}\n\n// NewPipeline creates a new Pipeline object from the specified Policies.\n// Not directly exported, but used as part of runtime.NewPipeline().\nfunc NewPipeline(transport Transporter, policies ...Policy) Pipeline {\n\t// transport policy must always be the last in the slice\n\tpolicies = append(policies, transportPolicy{trans: transport})\n\treturn Pipeline{\n\t\tpolicies: policies,\n\t}\n}\n\n// Do is called for each and every HTTP request. It passes the request through all\n// the Policy objects (which can transform the Request's URL/query parameters/headers)\n// and ultimately sends the transformed HTTP request over the network.\nfunc (p Pipeline) Do(req *Request) (*http.Response, error) {\n\tif req == nil {\n\t\treturn nil, errors.New(\"request cannot be nil\")\n\t}\n\treq.policies = p.policies\n\treturn req.Next()\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported/request.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage exported\n\nimport (\n\t\"bytes\"\n\t\"context\"\n\t\"encoding/base64\"\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n\t\"reflect\"\n\t\"strconv\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n)\n\n// Base64Encoding is usesd to specify which base-64 encoder/decoder to use when\n// encoding/decoding a slice of bytes to/from a string.\n// Exported as runtime.Base64Encoding\ntype Base64Encoding int\n\nconst (\n\t// Base64StdFormat uses base64.StdEncoding for encoding and decoding payloads.\n\tBase64StdFormat Base64Encoding = 0\n\n\t// Base64URLFormat uses base64.RawURLEncoding for encoding and decoding payloads.\n\tBase64URLFormat Base64Encoding = 1\n)\n\n// EncodeByteArray will base-64 encode the byte slice v.\n// Exported as runtime.EncodeByteArray()\nfunc EncodeByteArray(v []byte, format Base64Encoding) string {\n\tif format == Base64URLFormat {\n\t\treturn base64.RawURLEncoding.EncodeToString(v)\n\t}\n\treturn base64.StdEncoding.EncodeToString(v)\n}\n\n// Request is an abstraction over the creation of an HTTP request as it passes through the pipeline.\n// Don't use this type directly, use NewRequest() instead.\n// Exported as policy.Request.\ntype Request struct {\n\treq *http.Request\n\tbody io.ReadSeekCloser\n\tpolicies []Policy\n\tvalues opValues\n}\n\ntype opValues map[reflect.Type]any\n\n// Set adds/changes a value\nfunc (ov opValues) set(value any) {\n\tov[reflect.TypeOf(value)] = value\n}\n\n// Get looks for a value set by SetValue first\nfunc (ov opValues) get(value any) bool {\n\tv, ok := ov[reflect.ValueOf(value).Elem().Type()]\n\tif ok {\n\t\treflect.ValueOf(value).Elem().Set(reflect.ValueOf(v))\n\t}\n\treturn ok\n}\n\n// NewRequestFromRequest creates a new policy.Request with an existing *http.Request\n// Exported as runtime.NewRequestFromRequest().\nfunc NewRequestFromRequest(req *http.Request) (*Request, error) {\n\tpolicyReq := &Request{req: req}\n\n\tif req.Body != nil {\n\t\t// we can avoid a body copy here if the underlying stream is already a\n\t\t// ReadSeekCloser.\n\t\treadSeekCloser, isReadSeekCloser := req.Body.(io.ReadSeekCloser)\n\n\t\tif !isReadSeekCloser {\n\t\t\t// since this is an already populated http.Request we want to copy\n\t\t\t// over its body, if it has one.\n\t\t\tbodyBytes, err := io.ReadAll(req.Body)\n\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\n\t\t\tif err := req.Body.Close(); err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\n\t\t\treadSeekCloser = NopCloser(bytes.NewReader(bodyBytes))\n\t\t}\n\n\t\t// SetBody also takes care of updating the http.Request's body\n\t\t// as well, so they should stay in-sync from this point.\n\t\tif err := policyReq.SetBody(readSeekCloser, req.Header.Get(\"Content-Type\")); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\n\treturn policyReq, nil\n}\n\n// NewRequest creates a new Request with the specified input.\n// Exported as runtime.NewRequest().\nfunc NewRequest(ctx context.Context, httpMethod string, endpoint string) (*Request, error) {\n\treq, err := http.NewRequestWithContext(ctx, httpMethod, endpoint, nil)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tif req.URL.Host == \"\" {\n\t\treturn nil, errors.New(\"no Host in request URL\")\n\t}\n\tif !(req.URL.Scheme == \"http\" || req.URL.Scheme == \"https\") {\n\t\treturn nil, fmt.Errorf(\"unsupported protocol scheme %s\", req.URL.Scheme)\n\t}\n\treturn &Request{req: req}, nil\n}\n\n// Body returns the original body specified when the Request was created.\nfunc (req *Request) Body() io.ReadSeekCloser {\n\treturn req.body\n}\n\n// Raw returns the underlying HTTP request.\nfunc (req *Request) Raw() *http.Request {\n\treturn req.req\n}\n\n// Next calls the next policy in the pipeline.\n// If there are no more policies, nil and an error are returned.\n// This method is intended to be called from pipeline policies.\n// To send a request through a pipeline call Pipeline.Do().\nfunc (req *Request) Next() (*http.Response, error) {\n\tif len(req.policies) == 0 {\n\t\treturn nil, errors.New(\"no more policies\")\n\t}\n\tnextPolicy := req.policies[0]\n\tnextReq := *req\n\tnextReq.policies = nextReq.policies[1:]\n\treturn nextPolicy.Do(&nextReq)\n}\n\n// SetOperationValue adds/changes a mutable key/value associated with a single operation.\nfunc (req *Request) SetOperationValue(value any) {\n\tif req.values == nil {\n\t\treq.values = opValues{}\n\t}\n\treq.values.set(value)\n}\n\n// OperationValue looks for a value set by SetOperationValue().\nfunc (req *Request) OperationValue(value any) bool {\n\tif req.values == nil {\n\t\treturn false\n\t}\n\treturn req.values.get(value)\n}\n\n// SetBody sets the specified ReadSeekCloser as the HTTP request body, and sets Content-Type and Content-Length\n// accordingly. If the ReadSeekCloser is nil or empty, Content-Length won't be set. If contentType is \"\",\n// Content-Type won't be set, and if it was set, will be deleted.\n// Use streaming.NopCloser to turn an io.ReadSeeker into an io.ReadSeekCloser.\nfunc (req *Request) SetBody(body io.ReadSeekCloser, contentType string) error {\n\t// clobber the existing Content-Type to preserve behavior\n\treturn SetBody(req, body, contentType, true)\n}\n\n// RewindBody seeks the request's Body stream back to the beginning so it can be resent when retrying an operation.\nfunc (req *Request) RewindBody() error {\n\tif req.body != nil {\n\t\t// Reset the stream back to the beginning and restore the body\n\t\t_, err := req.body.Seek(0, io.SeekStart)\n\t\treq.req.Body = req.body\n\t\treturn err\n\t}\n\treturn nil\n}\n\n// Close closes the request body.\nfunc (req *Request) Close() error {\n\tif req.body == nil {\n\t\treturn nil\n\t}\n\treturn req.body.Close()\n}\n\n// Clone returns a deep copy of the request with its context changed to ctx.\nfunc (req *Request) Clone(ctx context.Context) *Request {\n\tr2 := *req\n\tr2.req = req.req.Clone(ctx)\n\treturn &r2\n}\n\n// WithContext returns a shallow copy of the request with its context changed to ctx.\nfunc (req *Request) WithContext(ctx context.Context) *Request {\n\tr2 := new(Request)\n\t*r2 = *req\n\tr2.req = r2.req.WithContext(ctx)\n\treturn r2\n}\n\n// not exported but dependent on Request\n\n// PolicyFunc is a type that implements the Policy interface.\n// Use this type when implementing a stateless policy as a first-class function.\ntype PolicyFunc func(*Request) (*http.Response, error)\n\n// Do implements the Policy interface on policyFunc.\nfunc (pf PolicyFunc) Do(req *Request) (*http.Response, error) {\n\treturn pf(req)\n}\n\n// SetBody sets the specified ReadSeekCloser as the HTTP request body, and sets Content-Type and Content-Length accordingly.\n// - req is the request to modify\n// - body is the request body; if nil or empty, Content-Length won't be set\n// - contentType is the value for the Content-Type header; if empty, Content-Type will be deleted\n// - clobberContentType when true, will overwrite the existing value of Content-Type with contentType\nfunc SetBody(req *Request, body io.ReadSeekCloser, contentType string, clobberContentType bool) error {\n\tvar err error\n\tvar size int64\n\tif body != nil {\n\t\tsize, err = body.Seek(0, io.SeekEnd) // Seek to the end to get the stream's size\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\tif size == 0 {\n\t\t// treat an empty stream the same as a nil one: assign req a nil body\n\t\tbody = nil\n\t\t// RFC 9110 specifies a client shouldn't set Content-Length on a request containing no content\n\t\t// (Del is a no-op when the header has no value)\n\t\treq.req.Header.Del(shared.HeaderContentLength)\n\t} else {\n\t\t_, err = body.Seek(0, io.SeekStart)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treq.req.Header.Set(shared.HeaderContentLength, strconv.FormatInt(size, 10))\n\t\treq.Raw().GetBody = func() (io.ReadCloser, error) {\n\t\t\t_, err := body.Seek(0, io.SeekStart) // Seek back to the beginning of the stream\n\t\t\treturn body, err\n\t\t}\n\t}\n\t// keep a copy of the body argument. this is to handle cases\n\t// where req.Body is replaced, e.g. httputil.DumpRequest and friends.\n\treq.body = body\n\treq.req.Body = body\n\treq.req.ContentLength = size\n\tif contentType == \"\" {\n\t\t// Del is a no-op when the header has no value\n\t\treq.req.Header.Del(shared.HeaderContentType)\n\t} else if req.req.Header.Get(shared.HeaderContentType) == \"\" || clobberContentType {\n\t\treq.req.Header.Set(shared.HeaderContentType, contentType)\n\t}\n\treturn nil\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported/response_error.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage exported\n\nimport (\n\t\"bytes\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"regexp\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/log\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/exported\"\n)\n\n// NewResponseError creates a new *ResponseError from the provided HTTP response.\n// Exported as runtime.NewResponseError().\nfunc NewResponseError(resp *http.Response) error {\n\t// prefer the error code in the response header\n\tif ec := resp.Header.Get(shared.HeaderXMSErrorCode); ec != \"\" {\n\t\treturn NewResponseErrorWithErrorCode(resp, ec)\n\t}\n\n\t// if we didn't get x-ms-error-code, check in the response body\n\tbody, err := exported.Payload(resp, nil)\n\tif err != nil {\n\t\t// since we're not returning the ResponseError in this\n\t\t// case we also don't want to write it to the log.\n\t\treturn err\n\t}\n\n\tvar errorCode string\n\tif len(body) > 0 {\n\t\tif fromJSON := extractErrorCodeJSON(body); fromJSON != \"\" {\n\t\t\terrorCode = fromJSON\n\t\t} else if fromXML := extractErrorCodeXML(body); fromXML != \"\" {\n\t\t\terrorCode = fromXML\n\t\t}\n\t}\n\n\treturn NewResponseErrorWithErrorCode(resp, errorCode)\n}\n\n// NewResponseErrorWithErrorCode creates an *azcore.ResponseError from the provided HTTP response and errorCode.\n// Exported as runtime.NewResponseErrorWithErrorCode().\nfunc NewResponseErrorWithErrorCode(resp *http.Response, errorCode string) error {\n\trespErr := &ResponseError{\n\t\tErrorCode: errorCode,\n\t\tStatusCode: resp.StatusCode,\n\t\tRawResponse: resp,\n\t}\n\tlog.Write(log.EventResponseError, respErr.Error())\n\treturn respErr\n}\n\nfunc extractErrorCodeJSON(body []byte) string {\n\tvar rawObj map[string]any\n\tif err := json.Unmarshal(body, &rawObj); err != nil {\n\t\t// not a JSON object\n\t\treturn \"\"\n\t}\n\n\t// check if this is a wrapped error, i.e. { \"error\": { ... } }\n\t// if so then unwrap it\n\tif wrapped, ok := rawObj[\"error\"]; ok {\n\t\tunwrapped, ok := wrapped.(map[string]any)\n\t\tif !ok {\n\t\t\treturn \"\"\n\t\t}\n\t\trawObj = unwrapped\n\t} else if wrapped, ok := rawObj[\"odata.error\"]; ok {\n\t\t// check if this a wrapped odata error, i.e. { \"odata.error\": { ... } }\n\t\tunwrapped, ok := wrapped.(map[string]any)\n\t\tif !ok {\n\t\t\treturn \"\"\n\t\t}\n\t\trawObj = unwrapped\n\t}\n\n\t// now check for the error code\n\tcode, ok := rawObj[\"code\"]\n\tif !ok {\n\t\treturn \"\"\n\t}\n\tcodeStr, ok := code.(string)\n\tif !ok {\n\t\treturn \"\"\n\t}\n\treturn codeStr\n}\n\nfunc extractErrorCodeXML(body []byte) string {\n\t// regular expression is much easier than dealing with the XML parser\n\trx := regexp.MustCompile(`<(?:\\w+:)?[c|C]ode>\\s*(\\w+)\\s*<\\/(?:\\w+:)?[c|C]ode>`)\n\tres := rx.FindStringSubmatch(string(body))\n\tif len(res) != 2 {\n\t\treturn \"\"\n\t}\n\t// first submatch is the entire thing, second one is the captured error code\n\treturn res[1]\n}\n\n// ResponseError is returned when a request is made to a service and\n// the service returns a non-success HTTP status code.\n// Use errors.As() to access this type in the error chain.\n// Exported as azcore.ResponseError.\ntype ResponseError struct {\n\t// ErrorCode is the error code returned by the resource provider if available.\n\tErrorCode string\n\n\t// StatusCode is the HTTP status code as defined in https://pkg.go.dev/net/http#pkg-constants.\n\tStatusCode int\n\n\t// RawResponse is the underlying HTTP response.\n\tRawResponse *http.Response `json:\"-\"`\n\n\terrMsg string\n}\n\n// Error implements the error interface for type ResponseError.\n// Note that the message contents are not contractual and can change over time.\nfunc (e *ResponseError) Error() string {\n\tif e.errMsg != \"\" {\n\t\treturn e.errMsg\n\t}\n\n\tconst separator = \"--------------------------------------------------------------------------------\"\n\t// write the request method and URL with response status code\n\tmsg := &bytes.Buffer{}\n\tif e.RawResponse != nil {\n\t\tif e.RawResponse.Request != nil {\n\t\t\tfmt.Fprintf(msg, \"%s %s://%s%s\\n\", e.RawResponse.Request.Method, e.RawResponse.Request.URL.Scheme, e.RawResponse.Request.URL.Host, e.RawResponse.Request.URL.Path)\n\t\t} else {\n\t\t\tfmt.Fprintln(msg, \"Request information not available\")\n\t\t}\n\t\tfmt.Fprintln(msg, separator)\n\t\tfmt.Fprintf(msg, \"RESPONSE %d: %s\\n\", e.RawResponse.StatusCode, e.RawResponse.Status)\n\t} else {\n\t\tfmt.Fprintln(msg, \"Missing RawResponse\")\n\t\tfmt.Fprintln(msg, separator)\n\t}\n\tif e.ErrorCode != \"\" {\n\t\tfmt.Fprintf(msg, \"ERROR CODE: %s\\n\", e.ErrorCode)\n\t} else {\n\t\tfmt.Fprintln(msg, \"ERROR CODE UNAVAILABLE\")\n\t}\n\tif e.RawResponse != nil {\n\t\tfmt.Fprintln(msg, separator)\n\t\tbody, err := exported.Payload(e.RawResponse, nil)\n\t\tif err != nil {\n\t\t\t// this really shouldn't fail at this point as the response\n\t\t\t// body is already cached (it was read in NewResponseError)\n\t\t\tfmt.Fprintf(msg, \"Error reading response body: %v\", err)\n\t\t} else if len(body) > 0 {\n\t\t\tif err := json.Indent(msg, body, \"\", \" \"); err != nil {\n\t\t\t\t// failed to pretty-print so just dump it verbatim\n\t\t\t\tfmt.Fprint(msg, string(body))\n\t\t\t}\n\t\t\t// the standard library doesn't have a pretty-printer for XML\n\t\t\tfmt.Fprintln(msg)\n\t\t} else {\n\t\t\tfmt.Fprintln(msg, \"Response contained no body\")\n\t\t}\n\t}\n\tfmt.Fprintln(msg, separator)\n\n\te.errMsg = msg.String()\n\treturn e.errMsg\n}\n\n// internal type used for marshaling/unmarshaling\ntype responseError struct {\n\tErrorCode string `json:\"errorCode\"`\n\tStatusCode int `json:\"statusCode\"`\n\tErrorMessage string `json:\"errorMessage\"`\n}\n\nfunc (e ResponseError) MarshalJSON() ([]byte, error) {\n\treturn json.Marshal(responseError{\n\t\tErrorCode: e.ErrorCode,\n\t\tStatusCode: e.StatusCode,\n\t\tErrorMessage: e.Error(),\n\t})\n}\n\nfunc (e *ResponseError) UnmarshalJSON(data []byte) error {\n\tre := responseError{}\n\tif err := json.Unmarshal(data, &re); err != nil {\n\t\treturn err\n\t}\n\n\te.ErrorCode = re.ErrorCode\n\te.StatusCode = re.StatusCode\n\te.errMsg = re.ErrorMessage\n\treturn nil\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/log/log.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// This is an internal helper package to combine the complete logging APIs.\npackage log\n\nimport (\n\tazlog \"github.com/Azure/azure-sdk-for-go/sdk/azcore/log\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/log\"\n)\n\ntype Event = log.Event\n\nconst (\n\tEventRequest = azlog.EventRequest\n\tEventResponse = azlog.EventResponse\n\tEventResponseError = azlog.EventResponseError\n\tEventRetryPolicy = azlog.EventRetryPolicy\n\tEventLRO = azlog.EventLRO\n)\n\n// Write invokes the underlying listener with the specified event and message.\n// If the event shouldn't be logged or there is no listener then Write does nothing.\nfunc Write(cls log.Event, msg string) {\n\tlog.Write(cls, msg)\n}\n\n// Writef invokes the underlying listener with the specified event and formatted message.\n// If the event shouldn't be logged or there is no listener then Writef does nothing.\nfunc Writef(cls log.Event, format string, a ...any) {\n\tlog.Writef(cls, format, a...)\n}\n\n// SetListener will set the Logger to write to the specified listener.\nfunc SetListener(lst func(Event, string)) {\n\tlog.SetListener(lst)\n}\n\n// Should returns true if the specified log event should be written to the log.\n// By default all log events will be logged. Call SetEvents() to limit\n// the log events for logging.\n// If no listener has been set this will return false.\n// Calling this method is useful when the message to log is computationally expensive\n// and you want to avoid the overhead if its log event is not enabled.\nfunc Should(cls log.Event) bool {\n\treturn log.Should(cls)\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers/async/async.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage async\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"net/http\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/log\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/poller\"\n)\n\n// see https://github.com/Azure/azure-resource-manager-rpc/blob/master/v1.0/async-api-reference.md\n\n// Applicable returns true if the LRO is using Azure-AsyncOperation.\nfunc Applicable(resp *http.Response) bool {\n\treturn resp.Header.Get(shared.HeaderAzureAsync) != \"\"\n}\n\n// CanResume returns true if the token can rehydrate this poller type.\nfunc CanResume(token map[string]any) bool {\n\t_, ok := token[\"asyncURL\"]\n\treturn ok\n}\n\n// Poller is an LRO poller that uses the Azure-AsyncOperation pattern.\ntype Poller[T any] struct {\n\tpl exported.Pipeline\n\n\tresp *http.Response\n\n\t// The URL from Azure-AsyncOperation header.\n\tAsyncURL string `json:\"asyncURL\"`\n\n\t// The URL from Location header.\n\tLocURL string `json:\"locURL\"`\n\n\t// The URL from the initial LRO request.\n\tOrigURL string `json:\"origURL\"`\n\n\t// The HTTP method from the initial LRO request.\n\tMethod string `json:\"method\"`\n\n\t// The value of final-state-via from swagger, can be the empty string.\n\tFinalState pollers.FinalStateVia `json:\"finalState\"`\n\n\t// The LRO's current state.\n\tCurState string `json:\"state\"`\n}\n\n// New creates a new Poller from the provided initial response and final-state type.\n// Pass nil for response to create an empty Poller for rehydration.\nfunc New[T any](pl exported.Pipeline, resp *http.Response, finalState pollers.FinalStateVia) (*Poller[T], error) {\n\tif resp == nil {\n\t\tlog.Write(log.EventLRO, \"Resuming Azure-AsyncOperation poller.\")\n\t\treturn &Poller[T]{pl: pl}, nil\n\t}\n\tlog.Write(log.EventLRO, \"Using Azure-AsyncOperation poller.\")\n\tasyncURL := resp.Header.Get(shared.HeaderAzureAsync)\n\tif asyncURL == \"\" {\n\t\treturn nil, errors.New(\"response is missing Azure-AsyncOperation header\")\n\t}\n\tif !poller.IsValidURL(asyncURL) {\n\t\treturn nil, fmt.Errorf(\"invalid polling URL %s\", asyncURL)\n\t}\n\t// check for provisioning state. if the operation is a RELO\n\t// and terminates synchronously this will prevent extra polling.\n\t// it's ok if there's no provisioning state.\n\tstate, _ := poller.GetProvisioningState(resp)\n\tif state == \"\" {\n\t\tstate = poller.StatusInProgress\n\t}\n\tp := &Poller[T]{\n\t\tpl: pl,\n\t\tresp: resp,\n\t\tAsyncURL: asyncURL,\n\t\tLocURL: resp.Header.Get(shared.HeaderLocation),\n\t\tOrigURL: resp.Request.URL.String(),\n\t\tMethod: resp.Request.Method,\n\t\tFinalState: finalState,\n\t\tCurState: state,\n\t}\n\treturn p, nil\n}\n\n// Done returns true if the LRO is in a terminal state.\nfunc (p *Poller[T]) Done() bool {\n\treturn poller.IsTerminalState(p.CurState)\n}\n\n// Poll retrieves the current state of the LRO.\nfunc (p *Poller[T]) Poll(ctx context.Context) (*http.Response, error) {\n\terr := pollers.PollHelper(ctx, p.AsyncURL, p.pl, func(resp *http.Response) (string, error) {\n\t\tif !poller.StatusCodeValid(resp) {\n\t\t\tp.resp = resp\n\t\t\treturn \"\", exported.NewResponseError(resp)\n\t\t}\n\t\tstate, err := poller.GetStatus(resp)\n\t\tif err != nil {\n\t\t\treturn \"\", err\n\t\t} else if state == \"\" {\n\t\t\treturn \"\", errors.New(\"the response did not contain a status\")\n\t\t}\n\t\tp.resp = resp\n\t\tp.CurState = state\n\t\treturn p.CurState, nil\n\t})\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn p.resp, nil\n}\n\nfunc (p *Poller[T]) Result(ctx context.Context, out *T) error {\n\tif p.resp.StatusCode == http.StatusNoContent {\n\t\treturn nil\n\t} else if poller.Failed(p.CurState) {\n\t\treturn exported.NewResponseError(p.resp)\n\t}\n\tvar req *exported.Request\n\tvar err error\n\tif p.Method == http.MethodPatch || p.Method == http.MethodPut {\n\t\t// for PATCH and PUT, the final GET is on the original resource URL\n\t\treq, err = exported.NewRequest(ctx, http.MethodGet, p.OrigURL)\n\t} else if p.Method == http.MethodPost {\n\t\tif p.FinalState == pollers.FinalStateViaAzureAsyncOp {\n\t\t\t// no final GET required\n\t\t} else if p.FinalState == pollers.FinalStateViaOriginalURI {\n\t\t\treq, err = exported.NewRequest(ctx, http.MethodGet, p.OrigURL)\n\t\t} else if p.LocURL != \"\" {\n\t\t\t// ideally FinalState would be set to \"location\" but it isn't always.\n\t\t\t// must check last due to more permissive condition.\n\t\t\treq, err = exported.NewRequest(ctx, http.MethodGet, p.LocURL)\n\t\t}\n\t}\n\tif err != nil {\n\t\treturn err\n\t}\n\n\t// if a final GET request has been created, execute it\n\tif req != nil {\n\t\tresp, err := p.pl.Do(req)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tp.resp = resp\n\t}\n\n\treturn pollers.ResultHelper(p.resp, poller.Failed(p.CurState), \"\", out)\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers/body/body.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage body\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"net/http\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/log\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/poller\"\n)\n\n// Kind is the identifier of this type in a resume token.\nconst kind = \"body\"\n\n// Applicable returns true if the LRO is using no headers, just provisioning state.\n// This is only applicable to PATCH and PUT methods and assumes no polling headers.\nfunc Applicable(resp *http.Response) bool {\n\t// we can't check for absense of headers due to some misbehaving services\n\t// like redis that return a Location header but don't actually use that protocol\n\treturn resp.Request.Method == http.MethodPatch || resp.Request.Method == http.MethodPut\n}\n\n// CanResume returns true if the token can rehydrate this poller type.\nfunc CanResume(token map[string]any) bool {\n\tt, ok := token[\"type\"]\n\tif !ok {\n\t\treturn false\n\t}\n\ttt, ok := t.(string)\n\tif !ok {\n\t\treturn false\n\t}\n\treturn tt == kind\n}\n\n// Poller is an LRO poller that uses the Body pattern.\ntype Poller[T any] struct {\n\tpl exported.Pipeline\n\n\tresp *http.Response\n\n\t// The poller's type, used for resume token processing.\n\tType string `json:\"type\"`\n\n\t// The URL for polling.\n\tPollURL string `json:\"pollURL\"`\n\n\t// The LRO's current state.\n\tCurState string `json:\"state\"`\n}\n\n// New creates a new Poller from the provided initial response.\n// Pass nil for response to create an empty Poller for rehydration.\nfunc New[T any](pl exported.Pipeline, resp *http.Response) (*Poller[T], error) {\n\tif resp == nil {\n\t\tlog.Write(log.EventLRO, \"Resuming Body poller.\")\n\t\treturn &Poller[T]{pl: pl}, nil\n\t}\n\tlog.Write(log.EventLRO, \"Using Body poller.\")\n\tp := &Poller[T]{\n\t\tpl: pl,\n\t\tresp: resp,\n\t\tType: kind,\n\t\tPollURL: resp.Request.URL.String(),\n\t}\n\t// default initial state to InProgress. depending on the HTTP\n\t// status code and provisioning state, we might change the value.\n\tcurState := poller.StatusInProgress\n\tprovState, err := poller.GetProvisioningState(resp)\n\tif err != nil && !errors.Is(err, poller.ErrNoBody) {\n\t\treturn nil, err\n\t}\n\tif resp.StatusCode == http.StatusCreated && provState != \"\" {\n\t\t// absense of provisioning state is ok for a 201, means the operation is in progress\n\t\tcurState = provState\n\t} else if resp.StatusCode == http.StatusOK {\n\t\tif provState != \"\" {\n\t\t\tcurState = provState\n\t\t} else if provState == \"\" {\n\t\t\t// for a 200, absense of provisioning state indicates success\n\t\t\tcurState = poller.StatusSucceeded\n\t\t}\n\t} else if resp.StatusCode == http.StatusNoContent {\n\t\tcurState = poller.StatusSucceeded\n\t}\n\tp.CurState = curState\n\treturn p, nil\n}\n\nfunc (p *Poller[T]) Done() bool {\n\treturn poller.IsTerminalState(p.CurState)\n}\n\nfunc (p *Poller[T]) Poll(ctx context.Context) (*http.Response, error) {\n\terr := pollers.PollHelper(ctx, p.PollURL, p.pl, func(resp *http.Response) (string, error) {\n\t\tif !poller.StatusCodeValid(resp) {\n\t\t\tp.resp = resp\n\t\t\treturn \"\", exported.NewResponseError(resp)\n\t\t}\n\t\tif resp.StatusCode == http.StatusNoContent {\n\t\t\tp.resp = resp\n\t\t\tp.CurState = poller.StatusSucceeded\n\t\t\treturn p.CurState, nil\n\t\t}\n\t\tstate, err := poller.GetProvisioningState(resp)\n\t\tif errors.Is(err, poller.ErrNoBody) {\n\t\t\t// a missing response body in non-204 case is an error\n\t\t\treturn \"\", err\n\t\t} else if state == \"\" {\n\t\t\t// a response body without provisioning state is considered terminal success\n\t\t\tstate = poller.StatusSucceeded\n\t\t} else if err != nil {\n\t\t\treturn \"\", err\n\t\t}\n\t\tp.resp = resp\n\t\tp.CurState = state\n\t\treturn p.CurState, nil\n\t})\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn p.resp, nil\n}\n\nfunc (p *Poller[T]) Result(ctx context.Context, out *T) error {\n\treturn pollers.ResultHelper(p.resp, poller.Failed(p.CurState), \"\", out)\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers/fake/fake.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage fake\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"strings\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/log\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/poller\"\n)\n\n// Applicable returns true if the LRO is a fake.\nfunc Applicable(resp *http.Response) bool {\n\treturn resp.Header.Get(shared.HeaderFakePollerStatus) != \"\"\n}\n\n// CanResume returns true if the token can rehydrate this poller type.\nfunc CanResume(token map[string]any) bool {\n\t_, ok := token[\"fakeURL\"]\n\treturn ok\n}\n\n// Poller is an LRO poller that uses the Core-Fake-Poller pattern.\ntype Poller[T any] struct {\n\tpl exported.Pipeline\n\n\tresp *http.Response\n\n\t// The API name from CtxAPINameKey\n\tAPIName string `json:\"apiName\"`\n\n\t// The URL from Core-Fake-Poller header.\n\tFakeURL string `json:\"fakeURL\"`\n\n\t// The LRO's current state.\n\tFakeStatus string `json:\"status\"`\n}\n\n// lroStatusURLSuffix is the URL path suffix for a faked LRO.\nconst lroStatusURLSuffix = \"/get/fake/status\"\n\n// New creates a new Poller from the provided initial response.\n// Pass nil for response to create an empty Poller for rehydration.\nfunc New[T any](pl exported.Pipeline, resp *http.Response) (*Poller[T], error) {\n\tif resp == nil {\n\t\tlog.Write(log.EventLRO, \"Resuming Core-Fake-Poller poller.\")\n\t\treturn &Poller[T]{pl: pl}, nil\n\t}\n\n\tlog.Write(log.EventLRO, \"Using Core-Fake-Poller poller.\")\n\tfakeStatus := resp.Header.Get(shared.HeaderFakePollerStatus)\n\tif fakeStatus == \"\" {\n\t\treturn nil, errors.New(\"response is missing Fake-Poller-Status header\")\n\t}\n\n\tctxVal := resp.Request.Context().Value(shared.CtxAPINameKey{})\n\tif ctxVal == nil {\n\t\treturn nil, errors.New(\"missing value for CtxAPINameKey\")\n\t}\n\n\tapiName, ok := ctxVal.(string)\n\tif !ok {\n\t\treturn nil, fmt.Errorf(\"expected string for CtxAPINameKey, the type was %T\", ctxVal)\n\t}\n\n\tqp := \"\"\n\tif resp.Request.URL.RawQuery != \"\" {\n\t\tqp = \"?\" + resp.Request.URL.RawQuery\n\t}\n\n\tp := &Poller[T]{\n\t\tpl: pl,\n\t\tresp: resp,\n\t\tAPIName: apiName,\n\t\t// NOTE: any changes to this path format MUST be reflected in SanitizePollerPath()\n\t\tFakeURL: fmt.Sprintf(\"%s://%s%s%s%s\", resp.Request.URL.Scheme, resp.Request.URL.Host, resp.Request.URL.Path, lroStatusURLSuffix, qp),\n\t\tFakeStatus: fakeStatus,\n\t}\n\treturn p, nil\n}\n\n// Done returns true if the LRO is in a terminal state.\nfunc (p *Poller[T]) Done() bool {\n\treturn poller.IsTerminalState(p.FakeStatus)\n}\n\n// Poll retrieves the current state of the LRO.\nfunc (p *Poller[T]) Poll(ctx context.Context) (*http.Response, error) {\n\tctx = context.WithValue(ctx, shared.CtxAPINameKey{}, p.APIName)\n\terr := pollers.PollHelper(ctx, p.FakeURL, p.pl, func(resp *http.Response) (string, error) {\n\t\tif !poller.StatusCodeValid(resp) {\n\t\t\tp.resp = resp\n\t\t\treturn \"\", exported.NewResponseError(resp)\n\t\t}\n\t\tfakeStatus := resp.Header.Get(shared.HeaderFakePollerStatus)\n\t\tif fakeStatus == \"\" {\n\t\t\treturn \"\", errors.New(\"response is missing Fake-Poller-Status header\")\n\t\t}\n\t\tp.resp = resp\n\t\tp.FakeStatus = fakeStatus\n\t\treturn p.FakeStatus, nil\n\t})\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn p.resp, nil\n}\n\nfunc (p *Poller[T]) Result(ctx context.Context, out *T) error {\n\tif p.resp.StatusCode == http.StatusNoContent {\n\t\treturn nil\n\t} else if poller.Failed(p.FakeStatus) {\n\t\treturn exported.NewResponseError(p.resp)\n\t}\n\n\treturn pollers.ResultHelper(p.resp, poller.Failed(p.FakeStatus), \"\", out)\n}\n\n// SanitizePollerPath removes any fake-appended suffix from a URL's path.\nfunc SanitizePollerPath(path string) string {\n\treturn strings.TrimSuffix(path, lroStatusURLSuffix)\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers/loc/loc.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage loc\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"net/http\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/log\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/poller\"\n)\n\n// Kind is the identifier of this type in a resume token.\nconst kind = \"loc\"\n\n// Applicable returns true if the LRO is using Location.\nfunc Applicable(resp *http.Response) bool {\n\treturn resp.Header.Get(shared.HeaderLocation) != \"\"\n}\n\n// CanResume returns true if the token can rehydrate this poller type.\nfunc CanResume(token map[string]any) bool {\n\tt, ok := token[\"type\"]\n\tif !ok {\n\t\treturn false\n\t}\n\ttt, ok := t.(string)\n\tif !ok {\n\t\treturn false\n\t}\n\treturn tt == kind\n}\n\n// Poller is an LRO poller that uses the Location pattern.\ntype Poller[T any] struct {\n\tpl exported.Pipeline\n\tresp *http.Response\n\n\tType string `json:\"type\"`\n\tPollURL string `json:\"pollURL\"`\n\tCurState string `json:\"state\"`\n}\n\n// New creates a new Poller from the provided initial response.\n// Pass nil for response to create an empty Poller for rehydration.\nfunc New[T any](pl exported.Pipeline, resp *http.Response) (*Poller[T], error) {\n\tif resp == nil {\n\t\tlog.Write(log.EventLRO, \"Resuming Location poller.\")\n\t\treturn &Poller[T]{pl: pl}, nil\n\t}\n\tlog.Write(log.EventLRO, \"Using Location poller.\")\n\tlocURL := resp.Header.Get(shared.HeaderLocation)\n\tif locURL == \"\" {\n\t\treturn nil, errors.New(\"response is missing Location header\")\n\t}\n\tif !poller.IsValidURL(locURL) {\n\t\treturn nil, fmt.Errorf(\"invalid polling URL %s\", locURL)\n\t}\n\t// check for provisioning state. if the operation is a RELO\n\t// and terminates synchronously this will prevent extra polling.\n\t// it's ok if there's no provisioning state.\n\tstate, _ := poller.GetProvisioningState(resp)\n\tif state == \"\" {\n\t\tstate = poller.StatusInProgress\n\t}\n\treturn &Poller[T]{\n\t\tpl: pl,\n\t\tresp: resp,\n\t\tType: kind,\n\t\tPollURL: locURL,\n\t\tCurState: state,\n\t}, nil\n}\n\nfunc (p *Poller[T]) Done() bool {\n\treturn poller.IsTerminalState(p.CurState)\n}\n\nfunc (p *Poller[T]) Poll(ctx context.Context) (*http.Response, error) {\n\terr := pollers.PollHelper(ctx, p.PollURL, p.pl, func(resp *http.Response) (string, error) {\n\t\t// location polling can return an updated polling URL\n\t\tif h := resp.Header.Get(shared.HeaderLocation); h != \"\" {\n\t\t\tp.PollURL = h\n\t\t}\n\t\t// if provisioning state is available, use that. this is only\n\t\t// for some ARM LRO scenarios (e.g. DELETE with a Location header)\n\t\t// so if it's missing then use HTTP status code.\n\t\tprovState, _ := poller.GetProvisioningState(resp)\n\t\tp.resp = resp\n\t\tif provState != \"\" {\n\t\t\tp.CurState = provState\n\t\t} else if resp.StatusCode == http.StatusAccepted {\n\t\t\tp.CurState = poller.StatusInProgress\n\t\t} else if resp.StatusCode > 199 && resp.StatusCode < 300 {\n\t\t\t// any 2xx other than a 202 indicates success\n\t\t\tp.CurState = poller.StatusSucceeded\n\t\t} else if pollers.IsNonTerminalHTTPStatusCode(resp) {\n\t\t\t// the request timed out or is being throttled.\n\t\t\t// DO NOT include this as a terminal failure. preserve\n\t\t\t// the existing state and return the response.\n\t\t} else {\n\t\t\tp.CurState = poller.StatusFailed\n\t\t}\n\t\treturn p.CurState, nil\n\t})\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn p.resp, nil\n}\n\nfunc (p *Poller[T]) Result(ctx context.Context, out *T) error {\n\treturn pollers.ResultHelper(p.resp, poller.Failed(p.CurState), \"\", out)\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers/op/op.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage op\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"net/http\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/log\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/poller\"\n)\n\n// Applicable returns true if the LRO is using Operation-Location.\nfunc Applicable(resp *http.Response) bool {\n\treturn resp.Header.Get(shared.HeaderOperationLocation) != \"\"\n}\n\n// CanResume returns true if the token can rehydrate this poller type.\nfunc CanResume(token map[string]any) bool {\n\t_, ok := token[\"oplocURL\"]\n\treturn ok\n}\n\n// Poller is an LRO poller that uses the Operation-Location pattern.\ntype Poller[T any] struct {\n\tpl exported.Pipeline\n\tresp *http.Response\n\n\tOpLocURL string `json:\"oplocURL\"`\n\tLocURL string `json:\"locURL\"`\n\tOrigURL string `json:\"origURL\"`\n\tMethod string `json:\"method\"`\n\tFinalState pollers.FinalStateVia `json:\"finalState\"`\n\tResultPath string `json:\"resultPath\"`\n\tCurState string `json:\"state\"`\n}\n\n// New creates a new Poller from the provided initial response.\n// Pass nil for response to create an empty Poller for rehydration.\nfunc New[T any](pl exported.Pipeline, resp *http.Response, finalState pollers.FinalStateVia, resultPath string) (*Poller[T], error) {\n\tif resp == nil {\n\t\tlog.Write(log.EventLRO, \"Resuming Operation-Location poller.\")\n\t\treturn &Poller[T]{pl: pl}, nil\n\t}\n\tlog.Write(log.EventLRO, \"Using Operation-Location poller.\")\n\topURL := resp.Header.Get(shared.HeaderOperationLocation)\n\tif opURL == \"\" {\n\t\treturn nil, errors.New(\"response is missing Operation-Location header\")\n\t}\n\tif !poller.IsValidURL(opURL) {\n\t\treturn nil, fmt.Errorf(\"invalid Operation-Location URL %s\", opURL)\n\t}\n\tlocURL := resp.Header.Get(shared.HeaderLocation)\n\t// Location header is optional\n\tif locURL != \"\" && !poller.IsValidURL(locURL) {\n\t\treturn nil, fmt.Errorf(\"invalid Location URL %s\", locURL)\n\t}\n\t// default initial state to InProgress. if the\n\t// service sent us a status then use that instead.\n\tcurState := poller.StatusInProgress\n\tstatus, err := poller.GetStatus(resp)\n\tif err != nil && !errors.Is(err, poller.ErrNoBody) {\n\t\treturn nil, err\n\t}\n\tif status != \"\" {\n\t\tcurState = status\n\t}\n\n\treturn &Poller[T]{\n\t\tpl: pl,\n\t\tresp: resp,\n\t\tOpLocURL: opURL,\n\t\tLocURL: locURL,\n\t\tOrigURL: resp.Request.URL.String(),\n\t\tMethod: resp.Request.Method,\n\t\tFinalState: finalState,\n\t\tResultPath: resultPath,\n\t\tCurState: curState,\n\t}, nil\n}\n\nfunc (p *Poller[T]) Done() bool {\n\treturn poller.IsTerminalState(p.CurState)\n}\n\nfunc (p *Poller[T]) Poll(ctx context.Context) (*http.Response, error) {\n\terr := pollers.PollHelper(ctx, p.OpLocURL, p.pl, func(resp *http.Response) (string, error) {\n\t\tif !poller.StatusCodeValid(resp) {\n\t\t\tp.resp = resp\n\t\t\treturn \"\", exported.NewResponseError(resp)\n\t\t}\n\t\tstate, err := poller.GetStatus(resp)\n\t\tif err != nil {\n\t\t\treturn \"\", err\n\t\t} else if state == \"\" {\n\t\t\treturn \"\", errors.New(\"the response did not contain a status\")\n\t\t}\n\t\tp.resp = resp\n\t\tp.CurState = state\n\t\treturn p.CurState, nil\n\t})\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn p.resp, nil\n}\n\nfunc (p *Poller[T]) Result(ctx context.Context, out *T) error {\n\tvar req *exported.Request\n\tvar err error\n\n\tif p.FinalState == pollers.FinalStateViaLocation && p.LocURL != \"\" {\n\t\treq, err = exported.NewRequest(ctx, http.MethodGet, p.LocURL)\n\t} else if rl, rlErr := poller.GetResourceLocation(p.resp); rlErr != nil && !errors.Is(rlErr, poller.ErrNoBody) {\n\t\treturn rlErr\n\t} else if rl != \"\" {\n\t\treq, err = exported.NewRequest(ctx, http.MethodGet, rl)\n\t} else if p.Method == http.MethodPatch || p.Method == http.MethodPut {\n\t\treq, err = exported.NewRequest(ctx, http.MethodGet, p.OrigURL)\n\t} else if p.Method == http.MethodPost && p.LocURL != \"\" {\n\t\treq, err = exported.NewRequest(ctx, http.MethodGet, p.LocURL)\n\t}\n\tif err != nil {\n\t\treturn err\n\t}\n\n\t// if a final GET request has been created, execute it\n\tif req != nil {\n\t\t// no JSON path when making a final GET request\n\t\tp.ResultPath = \"\"\n\t\tresp, err := p.pl.Do(req)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tp.resp = resp\n\t}\n\n\treturn pollers.ResultHelper(p.resp, poller.Failed(p.CurState), p.ResultPath, out)\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers/poller.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage pollers\n\n// FinalStateVia is the enumerated type for the possible final-state-via values.\ntype FinalStateVia string\n\nconst (\n\t// FinalStateViaAzureAsyncOp indicates the final payload comes from the Azure-AsyncOperation URL.\n\tFinalStateViaAzureAsyncOp FinalStateVia = \"azure-async-operation\"\n\n\t// FinalStateViaLocation indicates the final payload comes from the Location URL.\n\tFinalStateViaLocation FinalStateVia = \"location\"\n\n\t// FinalStateViaOriginalURI indicates the final payload comes from the original URL.\n\tFinalStateViaOriginalURI FinalStateVia = \"original-uri\"\n\n\t// FinalStateViaOpLocation indicates the final payload comes from the Operation-Location URL.\n\tFinalStateViaOpLocation FinalStateVia = \"operation-location\"\n)\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/pollers/util.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage pollers\n\nimport (\n\t\"context\"\n\t\"encoding/json\"\n\t\"errors\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"reflect\"\n\n\tazexported \"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/log\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/exported\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/poller\"\n)\n\n// getTokenTypeName creates a type name from the type parameter T.\nfunc getTokenTypeName[T any]() (string, error) {\n\ttt := shared.TypeOfT[T]()\n\tvar n string\n\tif tt.Kind() == reflect.Pointer {\n\t\tn = \"*\"\n\t\ttt = tt.Elem()\n\t}\n\tn += tt.Name()\n\tif n == \"\" {\n\t\treturn \"\", errors.New(\"nameless types are not allowed\")\n\t}\n\treturn n, nil\n}\n\ntype resumeTokenWrapper[T any] struct {\n\tType string `json:\"type\"`\n\tToken T `json:\"token\"`\n}\n\n// NewResumeToken creates a resume token from the specified type.\n// An error is returned if the generic type has no name (e.g. struct{}).\nfunc NewResumeToken[TResult, TSource any](from TSource) (string, error) {\n\tn, err := getTokenTypeName[TResult]()\n\tif err != nil {\n\t\treturn \"\", err\n\t}\n\tb, err := json.Marshal(resumeTokenWrapper[TSource]{\n\t\tType: n,\n\t\tToken: from,\n\t})\n\tif err != nil {\n\t\treturn \"\", err\n\t}\n\treturn string(b), nil\n}\n\n// ExtractToken returns the poller-specific token information from the provided token value.\nfunc ExtractToken(token string) ([]byte, error) {\n\traw := map[string]json.RawMessage{}\n\tif err := json.Unmarshal([]byte(token), &raw); err != nil {\n\t\treturn nil, err\n\t}\n\t// this is dependent on the type resumeTokenWrapper[T]\n\ttk, ok := raw[\"token\"]\n\tif !ok {\n\t\treturn nil, errors.New(\"missing token value\")\n\t}\n\treturn tk, nil\n}\n\n// IsTokenValid returns an error if the specified token isn't applicable for generic type T.\nfunc IsTokenValid[T any](token string) error {\n\traw := map[string]any{}\n\tif err := json.Unmarshal([]byte(token), &raw); err != nil {\n\t\treturn err\n\t}\n\tt, ok := raw[\"type\"]\n\tif !ok {\n\t\treturn errors.New(\"missing type value\")\n\t}\n\ttt, ok := t.(string)\n\tif !ok {\n\t\treturn fmt.Errorf(\"invalid type format %T\", t)\n\t}\n\tn, err := getTokenTypeName[T]()\n\tif err != nil {\n\t\treturn err\n\t}\n\tif tt != n {\n\t\treturn fmt.Errorf(\"cannot resume from this poller token. token is for type %s, not %s\", tt, n)\n\t}\n\treturn nil\n}\n\n// used if the operation synchronously completed\ntype NopPoller[T any] struct {\n\tresp *http.Response\n\tresult T\n}\n\n// NewNopPoller creates a NopPoller from the provided response.\n// It unmarshals the response body into an instance of T.\nfunc NewNopPoller[T any](resp *http.Response) (*NopPoller[T], error) {\n\tnp := &NopPoller[T]{resp: resp}\n\tif resp.StatusCode == http.StatusNoContent {\n\t\treturn np, nil\n\t}\n\tpayload, err := exported.Payload(resp, nil)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tif len(payload) == 0 {\n\t\treturn np, nil\n\t}\n\tif err = json.Unmarshal(payload, &np.result); err != nil {\n\t\treturn nil, err\n\t}\n\treturn np, nil\n}\n\nfunc (*NopPoller[T]) Done() bool {\n\treturn true\n}\n\nfunc (p *NopPoller[T]) Poll(context.Context) (*http.Response, error) {\n\treturn p.resp, nil\n}\n\nfunc (p *NopPoller[T]) Result(ctx context.Context, out *T) error {\n\t*out = p.result\n\treturn nil\n}\n\n// PollHelper creates and executes the request, calling update() with the response.\n// If the request fails, the update func is not called.\n// The update func returns the state of the operation for logging purposes or an error\n// if it fails to extract the required state from the response.\nfunc PollHelper(ctx context.Context, endpoint string, pl azexported.Pipeline, update func(resp *http.Response) (string, error)) error {\n\treq, err := azexported.NewRequest(ctx, http.MethodGet, endpoint)\n\tif err != nil {\n\t\treturn err\n\t}\n\tresp, err := pl.Do(req)\n\tif err != nil {\n\t\treturn err\n\t}\n\tstate, err := update(resp)\n\tif err != nil {\n\t\treturn err\n\t}\n\tlog.Writef(log.EventLRO, \"State %s\", state)\n\treturn nil\n}\n\n// ResultHelper processes the response as success or failure.\n// In the success case, it unmarshals the payload into either a new instance of T or out.\n// In the failure case, it creates an *azcore.Response error from the response.\nfunc ResultHelper[T any](resp *http.Response, failed bool, jsonPath string, out *T) error {\n\t// short-circuit the simple success case with no response body to unmarshal\n\tif resp.StatusCode == http.StatusNoContent {\n\t\treturn nil\n\t}\n\n\tdefer resp.Body.Close()\n\tif !poller.StatusCodeValid(resp) || failed {\n\t\t// the LRO failed. unmarshall the error and update state\n\t\treturn azexported.NewResponseError(resp)\n\t}\n\n\t// success case\n\tpayload, err := exported.Payload(resp, nil)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\tif jsonPath != \"\" && len(payload) > 0 {\n\t\t// extract the payload from the specified JSON path.\n\t\t// do this before the zero-length check in case there\n\t\t// is no payload.\n\t\tjsonBody := map[string]json.RawMessage{}\n\t\tif err = json.Unmarshal(payload, &jsonBody); err != nil {\n\t\t\treturn err\n\t\t}\n\t\tpayload = jsonBody[jsonPath]\n\t}\n\n\tif len(payload) == 0 {\n\t\treturn nil\n\t}\n\n\tif err = json.Unmarshal(payload, out); err != nil {\n\t\treturn err\n\t}\n\treturn nil\n}\n\n// IsNonTerminalHTTPStatusCode returns true if the HTTP status code should be\n// considered non-terminal thus eligible for retry.\nfunc IsNonTerminalHTTPStatusCode(resp *http.Response) bool {\n\treturn exported.HasStatusCode(resp,\n\t\thttp.StatusRequestTimeout, // 408\n\t\thttp.StatusTooManyRequests, // 429\n\t\thttp.StatusInternalServerError, // 500\n\t\thttp.StatusBadGateway, // 502\n\t\thttp.StatusServiceUnavailable, // 503\n\t\thttp.StatusGatewayTimeout, // 504\n\t)\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared/constants.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage shared\n\nconst (\n\tContentTypeAppJSON = \"application/json\"\n\tContentTypeAppXML = \"application/xml\"\n\tContentTypeTextPlain = \"text/plain\"\n)\n\nconst (\n\tHeaderAuthorization = \"Authorization\"\n\tHeaderAuxiliaryAuthorization = \"x-ms-authorization-auxiliary\"\n\tHeaderAzureAsync = \"Azure-AsyncOperation\"\n\tHeaderContentLength = \"Content-Length\"\n\tHeaderContentType = \"Content-Type\"\n\tHeaderFakePollerStatus = \"Fake-Poller-Status\"\n\tHeaderLocation = \"Location\"\n\tHeaderOperationLocation = \"Operation-Location\"\n\tHeaderRetryAfter = \"Retry-After\"\n\tHeaderRetryAfterMS = \"Retry-After-Ms\"\n\tHeaderUserAgent = \"User-Agent\"\n\tHeaderWWWAuthenticate = \"WWW-Authenticate\"\n\tHeaderXMSClientRequestID = \"x-ms-client-request-id\"\n\tHeaderXMSRequestID = \"x-ms-request-id\"\n\tHeaderXMSErrorCode = \"x-ms-error-code\"\n\tHeaderXMSRetryAfterMS = \"x-ms-retry-after-ms\"\n)\n\nconst BearerTokenPrefix = \"Bearer \"\n\nconst TracingNamespaceAttrName = \"az.namespace\"\n\nconst (\n\t// Module is the name of the calling module used in telemetry data.\n\tModule = \"azcore\"\n\n\t// Version is the semantic version (see http://semver.org) of this module.\n\tVersion = \"v1.18.0\"\n)\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared/shared.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage shared\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"reflect\"\n\t\"regexp\"\n\t\"strconv\"\n\t\"time\"\n)\n\n// NOTE: when adding a new context key type, it likely needs to be\n// added to the deny-list of key types in ContextWithDeniedValues\n\n// CtxWithHTTPHeaderKey is used as a context key for adding/retrieving http.Header.\ntype CtxWithHTTPHeaderKey struct{}\n\n// CtxWithRetryOptionsKey is used as a context key for adding/retrieving RetryOptions.\ntype CtxWithRetryOptionsKey struct{}\n\n// CtxWithCaptureResponse is used as a context key for retrieving the raw response.\ntype CtxWithCaptureResponse struct{}\n\n// CtxWithTracingTracer is used as a context key for adding/retrieving tracing.Tracer.\ntype CtxWithTracingTracer struct{}\n\n// CtxAPINameKey is used as a context key for adding/retrieving the API name.\ntype CtxAPINameKey struct{}\n\n// Delay waits for the duration to elapse or the context to be cancelled.\nfunc Delay(ctx context.Context, delay time.Duration) error {\n\tselect {\n\tcase <-time.After(delay):\n\t\treturn nil\n\tcase <-ctx.Done():\n\t\treturn ctx.Err()\n\t}\n}\n\n// RetryAfter returns non-zero if the response contains one of the headers with a \"retry after\" value.\n// Headers are checked in the following order: retry-after-ms, x-ms-retry-after-ms, retry-after\nfunc RetryAfter(resp *http.Response) time.Duration {\n\tif resp == nil {\n\t\treturn 0\n\t}\n\n\ttype retryData struct {\n\t\theader string\n\t\tunits time.Duration\n\n\t\t// custom is used when the regular algorithm failed and is optional.\n\t\t// the returned duration is used verbatim (units is not applied).\n\t\tcustom func(string) time.Duration\n\t}\n\n\tnop := func(string) time.Duration { return 0 }\n\n\t// the headers are listed in order of preference\n\tretries := []retryData{\n\t\t{\n\t\t\theader: HeaderRetryAfterMS,\n\t\t\tunits: time.Millisecond,\n\t\t\tcustom: nop,\n\t\t},\n\t\t{\n\t\t\theader: HeaderXMSRetryAfterMS,\n\t\t\tunits: time.Millisecond,\n\t\t\tcustom: nop,\n\t\t},\n\t\t{\n\t\t\theader: HeaderRetryAfter,\n\t\t\tunits: time.Second,\n\n\t\t\t// retry-after values are expressed in either number of\n\t\t\t// seconds or an HTTP-date indicating when to try again\n\t\t\tcustom: func(ra string) time.Duration {\n\t\t\t\tt, err := time.Parse(time.RFC1123, ra)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn 0\n\t\t\t\t}\n\t\t\t\treturn time.Until(t)\n\t\t\t},\n\t\t},\n\t}\n\n\tfor _, retry := range retries {\n\t\tv := resp.Header.Get(retry.header)\n\t\tif v == \"\" {\n\t\t\tcontinue\n\t\t}\n\t\tif retryAfter, _ := strconv.Atoi(v); retryAfter > 0 {\n\t\t\treturn time.Duration(retryAfter) * retry.units\n\t\t} else if d := retry.custom(v); d > 0 {\n\t\t\treturn d\n\t\t}\n\t}\n\n\treturn 0\n}\n\n// TypeOfT returns the type of the generic type param.\nfunc TypeOfT[T any]() reflect.Type {\n\t// you can't, at present, obtain the type of\n\t// a type parameter, so this is the trick\n\treturn reflect.TypeOf((*T)(nil)).Elem()\n}\n\n// TransportFunc is a helper to use a first-class func to satisfy the Transporter interface.\ntype TransportFunc func(*http.Request) (*http.Response, error)\n\n// Do implements the Transporter interface for the TransportFunc type.\nfunc (pf TransportFunc) Do(req *http.Request) (*http.Response, error) {\n\treturn pf(req)\n}\n\n// ValidateModVer verifies that moduleVersion is a valid semver 2.0 string.\nfunc ValidateModVer(moduleVersion string) error {\n\tmodVerRegx := regexp.MustCompile(`^v\\d+\\.\\d+\\.\\d+(?:-[a-zA-Z0-9_.-]+)?$`)\n\tif !modVerRegx.MatchString(moduleVersion) {\n\t\treturn fmt.Errorf(\"malformed moduleVersion param value %s\", moduleVersion)\n\t}\n\treturn nil\n}\n\n// ContextWithDeniedValues wraps an existing [context.Context], denying access to certain context values.\n// Pipeline policies that create new requests to be sent down their own pipeline MUST wrap the caller's\n// context with an instance of this type. This is to prevent context values from flowing across disjoint\n// requests which can have unintended side-effects.\ntype ContextWithDeniedValues struct {\n\tcontext.Context\n}\n\n// Value implements part of the [context.Context] interface.\n// It acts as a deny-list for certain context keys.\nfunc (c *ContextWithDeniedValues) Value(key any) any {\n\tswitch key.(type) {\n\tcase CtxAPINameKey, CtxWithCaptureResponse, CtxWithHTTPHeaderKey, CtxWithRetryOptionsKey, CtxWithTracingTracer:\n\t\treturn nil\n\tdefault:\n\t\treturn c.Context.Value(key)\n\t}\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/log/doc.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright 2017 Microsoft Corporation. All rights reserved.\n// Use of this source code is governed by an MIT\n// license that can be found in the LICENSE file.\n\n// Package log contains functionality for configuring logging behavior.\n// Default logging to stderr can be enabled by setting environment variable AZURE_SDK_GO_LOGGING to \"all\".\npackage log\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/log/log.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// Package log provides functionality for configuring logging facilities.\npackage log\n\nimport (\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/log\"\n)\n\n// Event is used to group entries. Each group can be toggled on or off.\ntype Event = log.Event\n\nconst (\n\t// EventRequest entries contain information about HTTP requests.\n\t// This includes information like the URL, query parameters, and headers.\n\tEventRequest Event = \"Request\"\n\n\t// EventResponse entries contain information about HTTP responses.\n\t// This includes information like the HTTP status code, headers, and request URL.\n\tEventResponse Event = \"Response\"\n\n\t// EventResponseError entries contain information about HTTP responses that returned\n\t// an *azcore.ResponseError (i.e. responses with a non 2xx HTTP status code).\n\t// This includes the contents of ResponseError.Error().\n\tEventResponseError Event = \"ResponseError\"\n\n\t// EventRetryPolicy entries contain information specific to the retry policy in use.\n\tEventRetryPolicy Event = \"Retry\"\n\n\t// EventLRO entries contain information specific to long-running operations.\n\t// This includes information like polling location, operation state, and sleep intervals.\n\tEventLRO Event = \"LongRunningOperation\"\n)\n\n// SetEvents is used to control which events are written to\n// the log. By default all log events are writen.\n// NOTE: this is not goroutine safe and should be called before using SDK clients.\nfunc SetEvents(cls ...Event) {\n\tlog.SetEvents(cls...)\n}\n\n// SetListener will set the Logger to write to the specified Listener.\n// NOTE: this is not goroutine safe and should be called before using SDK clients.\nfunc SetListener(lst func(Event, string)) {\n\tlog.SetListener(lst)\n}\n\n// for testing purposes\nfunc resetEvents() {\n\tlog.TestResetEvents()\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/policy/doc.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright 2017 Microsoft Corporation. All rights reserved.\n// Use of this source code is governed by an MIT\n// license that can be found in the LICENSE file.\n\n// Package policy contains the definitions needed for configuring in-box pipeline policies\n// and creating custom policies.\npackage policy\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/policy/policy.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage policy\n\nimport (\n\t\"context\"\n\t\"net/http\"\n\t\"time\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/cloud\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/tracing\"\n)\n\n// Policy represents an extensibility point for the Pipeline that can mutate the specified\n// Request and react to the received Response.\ntype Policy = exported.Policy\n\n// Transporter represents an HTTP pipeline transport used to send HTTP requests and receive responses.\ntype Transporter = exported.Transporter\n\n// Request is an abstraction over the creation of an HTTP request as it passes through the pipeline.\n// Don't use this type directly, use runtime.NewRequest() instead.\ntype Request = exported.Request\n\n// ClientOptions contains optional settings for a client's pipeline.\n// Instances can be shared across calls to SDK client constructors when uniform configuration is desired.\n// Zero-value fields will have their specified default values applied during use.\ntype ClientOptions struct {\n\t// APIVersion overrides the default version requested of the service.\n\t// Set with caution as this package version has not been tested with arbitrary service versions.\n\tAPIVersion string\n\n\t// Cloud specifies a cloud for the client. The default is Azure Public Cloud.\n\tCloud cloud.Configuration\n\n\t// InsecureAllowCredentialWithHTTP enables authenticated requests over HTTP.\n\t// By default, authenticated requests to an HTTP endpoint are rejected by the client.\n\t// WARNING: setting this to true will allow sending the credential in clear text. Use with caution.\n\tInsecureAllowCredentialWithHTTP bool\n\n\t// Logging configures the built-in logging policy.\n\tLogging LogOptions\n\n\t// Retry configures the built-in retry policy.\n\tRetry RetryOptions\n\n\t// Telemetry configures the built-in telemetry policy.\n\tTelemetry TelemetryOptions\n\n\t// TracingProvider configures the tracing provider.\n\t// It defaults to a no-op tracer.\n\tTracingProvider tracing.Provider\n\n\t// Transport sets the transport for HTTP requests.\n\tTransport Transporter\n\n\t// PerCallPolicies contains custom policies to inject into the pipeline.\n\t// Each policy is executed once per request.\n\tPerCallPolicies []Policy\n\n\t// PerRetryPolicies contains custom policies to inject into the pipeline.\n\t// Each policy is executed once per request, and for each retry of that request.\n\tPerRetryPolicies []Policy\n}\n\n// LogOptions configures the logging policy's behavior.\ntype LogOptions struct {\n\t// IncludeBody indicates if request and response bodies should be included in logging.\n\t// The default value is false.\n\t// NOTE: enabling this can lead to disclosure of sensitive information, use with care.\n\tIncludeBody bool\n\n\t// AllowedHeaders is the slice of headers to log with their values intact.\n\t// All headers not in the slice will have their values REDACTED.\n\t// Applies to request and response headers.\n\tAllowedHeaders []string\n\n\t// AllowedQueryParams is the slice of query parameters to log with their values intact.\n\t// All query parameters not in the slice will have their values REDACTED.\n\tAllowedQueryParams []string\n}\n\n// RetryOptions configures the retry policy's behavior.\n// Zero-value fields will have their specified default values applied during use.\n// This allows for modification of a subset of fields.\ntype RetryOptions struct {\n\t// MaxRetries specifies the maximum number of attempts a failed operation will be retried\n\t// before producing an error.\n\t// The default value is three. A value less than zero means one try and no retries.\n\tMaxRetries int32\n\n\t// TryTimeout indicates the maximum time allowed for any single try of an HTTP request.\n\t// This is disabled by default. Specify a value greater than zero to enable.\n\t// NOTE: Setting this to a small value might cause premature HTTP request time-outs.\n\tTryTimeout time.Duration\n\n\t// RetryDelay specifies the initial amount of delay to use before retrying an operation.\n\t// The value is used only if the HTTP response does not contain a Retry-After header.\n\t// The delay increases exponentially with each retry up to the maximum specified by MaxRetryDelay.\n\t// The default value is four seconds. A value less than zero means no delay between retries.\n\tRetryDelay time.Duration\n\n\t// MaxRetryDelay specifies the maximum delay allowed before retrying an operation.\n\t// Typically the value is greater than or equal to the value specified in RetryDelay.\n\t// The default Value is 60 seconds. A value less than zero means there is no cap.\n\tMaxRetryDelay time.Duration\n\n\t// StatusCodes specifies the HTTP status codes that indicate the operation should be retried.\n\t// A nil slice will use the following values.\n\t// http.StatusRequestTimeout 408\n\t// http.StatusTooManyRequests 429\n\t// http.StatusInternalServerError 500\n\t// http.StatusBadGateway 502\n\t// http.StatusServiceUnavailable 503\n\t// http.StatusGatewayTimeout 504\n\t// Specifying values will replace the default values.\n\t// Specifying an empty slice will disable retries for HTTP status codes.\n\tStatusCodes []int\n\n\t// ShouldRetry evaluates if the retry policy should retry the request.\n\t// When specified, the function overrides comparison against the list of\n\t// HTTP status codes and error checking within the retry policy. Context\n\t// and NonRetriable errors remain evaluated before calling ShouldRetry.\n\t// The *http.Response and error parameters are mutually exclusive, i.e.\n\t// if one is nil, the other is not nil.\n\t// A return value of true means the retry policy should retry.\n\tShouldRetry func(*http.Response, error) bool\n}\n\n// TelemetryOptions configures the telemetry policy's behavior.\ntype TelemetryOptions struct {\n\t// ApplicationID is an application-specific identification string to add to the User-Agent.\n\t// It has a maximum length of 24 characters and must not contain any spaces.\n\tApplicationID string\n\n\t// Disabled will prevent the addition of any telemetry data to the User-Agent.\n\tDisabled bool\n}\n\n// TokenRequestOptions contain specific parameter that may be used by credentials types when attempting to get a token.\ntype TokenRequestOptions = exported.TokenRequestOptions\n\n// BearerTokenOptions configures the bearer token policy's behavior.\ntype BearerTokenOptions struct {\n\t// AuthorizationHandler allows SDK developers to run client-specific logic when BearerTokenPolicy must authorize a request.\n\t// When this field isn't set, the policy follows its default behavior of authorizing every request with a bearer token from\n\t// its given credential.\n\tAuthorizationHandler AuthorizationHandler\n\n\t// InsecureAllowCredentialWithHTTP enables authenticated requests over HTTP.\n\t// By default, authenticated requests to an HTTP endpoint are rejected by the client.\n\t// WARNING: setting this to true will allow sending the bearer token in clear text. Use with caution.\n\tInsecureAllowCredentialWithHTTP bool\n}\n\n// AuthorizationHandler allows SDK developers to insert custom logic that runs when BearerTokenPolicy must authorize a request.\ntype AuthorizationHandler struct {\n\t// OnRequest provides TokenRequestOptions the policy can use to acquire a token for a request. The policy calls OnRequest\n\t// whenever it needs a token and may call it multiple times for the same request. Its func parameter authorizes the request\n\t// with a token from the policy's credential. Implementations that need to perform I/O should use the Request's context,\n\t// available from Request.Raw().Context(). When OnRequest returns an error, the policy propagates that error and doesn't send\n\t// the request. When OnRequest is nil, the policy follows its default behavior, which is to authorize the request with a token\n\t// from its credential according to its configuration.\n\tOnRequest func(*Request, func(TokenRequestOptions) error) error\n\n\t// OnChallenge allows clients to implement custom HTTP authentication challenge handling. BearerTokenPolicy calls it upon\n\t// receiving a 401 response containing multiple Bearer challenges or a challenge BearerTokenPolicy itself can't handle.\n\t// OnChallenge is responsible for parsing challenge(s) (the Response's WWW-Authenticate header) and reauthorizing the\n\t// Request accordingly. Its func argument authorizes the Request with a token from the policy's credential using the given\n\t// TokenRequestOptions. OnChallenge should honor the Request's context, available from Request.Raw().Context(). When\n\t// OnChallenge returns nil, the policy will send the Request again.\n\tOnChallenge func(*Request, *http.Response, func(TokenRequestOptions) error) error\n}\n\n// WithCaptureResponse applies the HTTP response retrieval annotation to the parent context.\n// The resp parameter will contain the HTTP response after the request has completed.\nfunc WithCaptureResponse(parent context.Context, resp **http.Response) context.Context {\n\treturn context.WithValue(parent, shared.CtxWithCaptureResponse{}, resp)\n}\n\n// WithHTTPHeader adds the specified http.Header to the parent context.\n// Use this to specify custom HTTP headers at the API-call level.\n// Any overlapping headers will have their values replaced with the values specified here.\nfunc WithHTTPHeader(parent context.Context, header http.Header) context.Context {\n\treturn context.WithValue(parent, shared.CtxWithHTTPHeaderKey{}, header)\n}\n\n// WithRetryOptions adds the specified RetryOptions to the parent context.\n// Use this to specify custom RetryOptions at the API-call level.\nfunc WithRetryOptions(parent context.Context, options RetryOptions) context.Context {\n\treturn context.WithValue(parent, shared.CtxWithRetryOptionsKey{}, options)\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/doc.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright 2017 Microsoft Corporation. All rights reserved.\n// Use of this source code is governed by an MIT\n// license that can be found in the LICENSE file.\n\n// Package runtime contains various facilities for creating requests and handling responses.\n// The content is intended for SDK authors.\npackage runtime\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/errors.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage runtime\n\nimport (\n\t\"net/http\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported\"\n)\n\n// NewResponseError creates an *azcore.ResponseError from the provided HTTP response.\n// Call this when a service request returns a non-successful status code.\n// The error code will be extracted from the *http.Response, either from the x-ms-error-code\n// header (preferred) or attempted to be parsed from the response body.\nfunc NewResponseError(resp *http.Response) error {\n\treturn exported.NewResponseError(resp)\n}\n\n// NewResponseErrorWithErrorCode creates an *azcore.ResponseError from the provided HTTP response and errorCode.\n// Use this variant when the error code is in a non-standard location.\nfunc NewResponseErrorWithErrorCode(resp *http.Response, errorCode string) error {\n\treturn exported.NewResponseErrorWithErrorCode(resp, errorCode)\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/pager.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage runtime\n\nimport (\n\t\"context\"\n\t\"encoding/json\"\n\t\"errors\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"reflect\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/tracing\"\n)\n\n// PagingHandler contains the required data for constructing a Pager.\ntype PagingHandler[T any] struct {\n\t// More returns a boolean indicating if there are more pages to fetch.\n\t// It uses the provided page to make the determination.\n\tMore func(T) bool\n\n\t// Fetcher fetches the first and subsequent pages.\n\tFetcher func(context.Context, *T) (T, error)\n\n\t// Tracer contains the Tracer from the client that's creating the Pager.\n\tTracer tracing.Tracer\n}\n\n// Pager provides operations for iterating over paged responses.\n// Methods on this type are not safe for concurrent use.\ntype Pager[T any] struct {\n\tcurrent *T\n\thandler PagingHandler[T]\n\ttracer tracing.Tracer\n\tfirstPage bool\n}\n\n// NewPager creates an instance of Pager using the specified PagingHandler.\n// Pass a non-nil T for firstPage if the first page has already been retrieved.\nfunc NewPager[T any](handler PagingHandler[T]) *Pager[T] {\n\treturn &Pager[T]{\n\t\thandler: handler,\n\t\ttracer: handler.Tracer,\n\t\tfirstPage: true,\n\t}\n}\n\n// More returns true if there are more pages to retrieve.\nfunc (p *Pager[T]) More() bool {\n\tif p.current != nil {\n\t\treturn p.handler.More(*p.current)\n\t}\n\treturn true\n}\n\n// NextPage advances the pager to the next page.\nfunc (p *Pager[T]) NextPage(ctx context.Context) (T, error) {\n\tif p.current != nil {\n\t\tif p.firstPage {\n\t\t\t// we get here if it's an LRO-pager, we already have the first page\n\t\t\tp.firstPage = false\n\t\t\treturn *p.current, nil\n\t\t} else if !p.handler.More(*p.current) {\n\t\t\treturn *new(T), errors.New(\"no more pages\")\n\t\t}\n\t} else {\n\t\t// non-LRO case, first page\n\t\tp.firstPage = false\n\t}\n\n\tvar err error\n\tctx, endSpan := StartSpan(ctx, fmt.Sprintf(\"%s.NextPage\", shortenTypeName(reflect.TypeOf(*p).Name())), p.tracer, nil)\n\tdefer func() { endSpan(err) }()\n\n\tresp, err := p.handler.Fetcher(ctx, p.current)\n\tif err != nil {\n\t\treturn *new(T), err\n\t}\n\tp.current = &resp\n\treturn *p.current, nil\n}\n\n// UnmarshalJSON implements the json.Unmarshaler interface for Pager[T].\nfunc (p *Pager[T]) UnmarshalJSON(data []byte) error {\n\treturn json.Unmarshal(data, &p.current)\n}\n\n// FetcherForNextLinkOptions contains the optional values for [FetcherForNextLink].\ntype FetcherForNextLinkOptions struct {\n\t// NextReq is the func to be called when requesting subsequent pages.\n\t// Used for paged operations that have a custom next link operation.\n\tNextReq func(context.Context, string) (*policy.Request, error)\n\n\t// StatusCodes contains additional HTTP status codes indicating success.\n\t// The default value is http.StatusOK.\n\tStatusCodes []int\n}\n\n// FetcherForNextLink is a helper containing boilerplate code to simplify creating a PagingHandler[T].Fetcher from a next link URL.\n// - ctx is the [context.Context] controlling the lifetime of the HTTP operation\n// - pl is the [Pipeline] used to dispatch the HTTP request\n// - nextLink is the URL used to fetch the next page. the empty string indicates the first page is to be requested\n// - firstReq is the func to be called when creating the request for the first page\n// - options contains any optional parameters, pass nil to accept the default values\nfunc FetcherForNextLink(ctx context.Context, pl Pipeline, nextLink string, firstReq func(context.Context) (*policy.Request, error), options *FetcherForNextLinkOptions) (*http.Response, error) {\n\tvar req *policy.Request\n\tvar err error\n\tif options == nil {\n\t\toptions = &FetcherForNextLinkOptions{}\n\t}\n\tif nextLink == \"\" {\n\t\treq, err = firstReq(ctx)\n\t} else if nextLink, err = EncodeQueryParams(nextLink); err == nil {\n\t\tif options.NextReq != nil {\n\t\t\treq, err = options.NextReq(ctx, nextLink)\n\t\t} else {\n\t\t\treq, err = NewRequest(ctx, http.MethodGet, nextLink)\n\t\t}\n\t}\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tresp, err := pl.Do(req)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tsuccessCodes := []int{http.StatusOK}\n\tsuccessCodes = append(successCodes, options.StatusCodes...)\n\tif !HasStatusCode(resp, successCodes...) {\n\t\treturn nil, NewResponseError(resp)\n\t}\n\treturn resp, nil\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/pipeline.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage runtime\n\nimport (\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy\"\n)\n\n// PipelineOptions contains Pipeline options for SDK developers\ntype PipelineOptions struct {\n\t// AllowedHeaders is the slice of headers to log with their values intact.\n\t// All headers not in the slice will have their values REDACTED.\n\t// Applies to request and response headers.\n\tAllowedHeaders []string\n\n\t// AllowedQueryParameters is the slice of query parameters to log with their values intact.\n\t// All query parameters not in the slice will have their values REDACTED.\n\tAllowedQueryParameters []string\n\n\t// APIVersion overrides the default version requested of the service.\n\t// Set with caution as this package version has not been tested with arbitrary service versions.\n\tAPIVersion APIVersionOptions\n\n\t// PerCall contains custom policies to inject into the pipeline.\n\t// Each policy is executed once per request.\n\tPerCall []policy.Policy\n\n\t// PerRetry contains custom policies to inject into the pipeline.\n\t// Each policy is executed once per request, and for each retry of that request.\n\tPerRetry []policy.Policy\n\n\t// Tracing contains options used to configure distributed tracing.\n\tTracing TracingOptions\n}\n\n// TracingOptions contains tracing options for SDK developers.\ntype TracingOptions struct {\n\t// Namespace contains the value to use for the az.namespace span attribute.\n\tNamespace string\n}\n\n// Pipeline represents a primitive for sending HTTP requests and receiving responses.\n// Its behavior can be extended by specifying policies during construction.\ntype Pipeline = exported.Pipeline\n\n// NewPipeline creates a pipeline from connection options, with any additional policies as specified.\n// Policies from ClientOptions are placed after policies from PipelineOptions.\n// The module and version parameters are used by the telemetry policy, when enabled.\nfunc NewPipeline(module, version string, plOpts PipelineOptions, options *policy.ClientOptions) Pipeline {\n\tcp := policy.ClientOptions{}\n\tif options != nil {\n\t\tcp = *options\n\t}\n\tif len(plOpts.AllowedHeaders) > 0 {\n\t\theaders := make([]string, len(plOpts.AllowedHeaders)+len(cp.Logging.AllowedHeaders))\n\t\tcopy(headers, plOpts.AllowedHeaders)\n\t\theaders = append(headers, cp.Logging.AllowedHeaders...)\n\t\tcp.Logging.AllowedHeaders = headers\n\t}\n\tif len(plOpts.AllowedQueryParameters) > 0 {\n\t\tqp := make([]string, len(plOpts.AllowedQueryParameters)+len(cp.Logging.AllowedQueryParams))\n\t\tcopy(qp, plOpts.AllowedQueryParameters)\n\t\tqp = append(qp, cp.Logging.AllowedQueryParams...)\n\t\tcp.Logging.AllowedQueryParams = qp\n\t}\n\t// we put the includeResponsePolicy at the very beginning so that the raw response\n\t// is populated with the final response (some policies might mutate the response)\n\tpolicies := []policy.Policy{exported.PolicyFunc(includeResponsePolicy)}\n\tif cp.APIVersion != \"\" {\n\t\tpolicies = append(policies, newAPIVersionPolicy(cp.APIVersion, &plOpts.APIVersion))\n\t}\n\tif !cp.Telemetry.Disabled {\n\t\tpolicies = append(policies, NewTelemetryPolicy(module, version, &cp.Telemetry))\n\t}\n\tpolicies = append(policies, plOpts.PerCall...)\n\tpolicies = append(policies, cp.PerCallPolicies...)\n\tpolicies = append(policies, NewRetryPolicy(&cp.Retry))\n\tpolicies = append(policies, plOpts.PerRetry...)\n\tpolicies = append(policies, cp.PerRetryPolicies...)\n\tpolicies = append(policies, exported.PolicyFunc(httpHeaderPolicy))\n\tpolicies = append(policies, newHTTPTracePolicy(cp.Logging.AllowedQueryParams))\n\tpolicies = append(policies, NewLogPolicy(&cp.Logging))\n\tpolicies = append(policies, exported.PolicyFunc(bodyDownloadPolicy))\n\ttransport := cp.Transport\n\tif transport == nil {\n\t\ttransport = defaultHTTPClient\n\t}\n\treturn exported.NewPipeline(transport, policies...)\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/policy_api_version.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage runtime\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"net/http\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy\"\n)\n\n// APIVersionOptions contains options for API versions\ntype APIVersionOptions struct {\n\t// Location indicates where to set the version on a request, for example in a header or query param\n\tLocation APIVersionLocation\n\t// Name is the name of the header or query parameter, for example \"api-version\"\n\tName string\n}\n\n// APIVersionLocation indicates which part of a request identifies the service version\ntype APIVersionLocation int\n\nconst (\n\t// APIVersionLocationQueryParam indicates a query parameter\n\tAPIVersionLocationQueryParam = 0\n\t// APIVersionLocationHeader indicates a header\n\tAPIVersionLocationHeader = 1\n)\n\n// newAPIVersionPolicy constructs an APIVersionPolicy. If version is \"\", Do will be a no-op. If version\n// isn't empty and opts.Name is empty, Do will return an error.\nfunc newAPIVersionPolicy(version string, opts *APIVersionOptions) *apiVersionPolicy {\n\tif opts == nil {\n\t\topts = &APIVersionOptions{}\n\t}\n\treturn &apiVersionPolicy{location: opts.Location, name: opts.Name, version: version}\n}\n\n// apiVersionPolicy enables users to set the API version of every request a client sends.\ntype apiVersionPolicy struct {\n\t// location indicates whether \"name\" refers to a query parameter or header.\n\tlocation APIVersionLocation\n\n\t// name of the query param or header whose value should be overridden; provided by the client.\n\tname string\n\n\t// version is the value (provided by the user) that replaces the default version value.\n\tversion string\n}\n\n// Do sets the request's API version, if the policy is configured to do so, replacing any prior value.\nfunc (a *apiVersionPolicy) Do(req *policy.Request) (*http.Response, error) {\n\tif a.version != \"\" {\n\t\tif a.name == \"\" {\n\t\t\t// user set ClientOptions.APIVersion but the client ctor didn't set PipelineOptions.APIVersionOptions\n\t\t\treturn nil, errors.New(\"this client doesn't support overriding its API version\")\n\t\t}\n\t\tswitch a.location {\n\t\tcase APIVersionLocationHeader:\n\t\t\treq.Raw().Header.Set(a.name, a.version)\n\t\tcase APIVersionLocationQueryParam:\n\t\t\tq := req.Raw().URL.Query()\n\t\t\tq.Set(a.name, a.version)\n\t\t\treq.Raw().URL.RawQuery = q.Encode()\n\t\tdefault:\n\t\t\treturn nil, fmt.Errorf(\"unknown APIVersionLocation %d\", a.location)\n\t\t}\n\t}\n\treturn req.Next()\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/policy_bearer_token.go",
"content": "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage runtime\n\nimport (\n\t\"encoding/base64\"\n\t\"errors\"\n\t\"net/http\"\n\t\"regexp\"\n\t\"strings\"\n\t\"sync\"\n\t\"time\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/errorinfo\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/temporal\"\n)\n\n// BearerTokenPolicy authorizes requests with bearer tokens acquired from a TokenCredential.\n// It handles [Continuous Access Evaluation] (CAE) challenges. Clients needing to handle\n// additional authentication challenges, or needing more control over authorization, should\n// provide a [policy.AuthorizationHandler] in [policy.BearerTokenOptions].\n//\n// [Continuous Access Evaluation]: https://learn.microsoft.com/entra/identity/conditional-access/concept-continuous-access-evaluation\ntype BearerTokenPolicy struct {\n\t// mainResource is the resource to be retreived using the tenant specified in the credential\n\tmainResource *temporal.Resource[exported.AccessToken, acquiringResourceState]\n\t// the following fields are read-only\n\tauthzHandler policy.AuthorizationHandler\n\tcred exported.TokenCredential\n\tscopes []string\n\tallowHTTP bool\n}\n\ntype acquiringResourceState struct {\n\treq *policy.Request\n\tp *BearerTokenPolicy\n\ttro policy.TokenRequestOptions\n}\n\n// acquire acquires or updates the resource; only one\n// thread/goroutine at a time ever calls this function\nfunc acquire(state acquiringResourceState) (newResource exported.AccessToken, newExpiration time.Time, err error) {\n\ttk, err := state.p.cred.GetToken(&shared.ContextWithDeniedValues{Context: state.req.Raw().Context()}, state.tro)\n\tif err != nil {\n\t\treturn exported.AccessToken{}, time.Time{}, err\n\t}\n\treturn tk, tk.ExpiresOn, nil\n}\n\n// shouldRefresh determines whether the token should be refreshed. It's a variable so tests can replace it.\nvar shouldRefresh = func(tk exported.AccessToken, _ acquiringResourceState) bool {\n\tif tk.RefreshOn.IsZero() {\n\t\treturn tk.ExpiresOn.Add(-5 * time.Minute).Before(time.Now())\n\t}\n\t// no offset in this case because the authority suggested a refresh window--between RefreshOn and ExpiresOn\n\treturn tk.RefreshOn.Before(time.Now())\n}\n\n// NewBearerTokenPolicy creates a policy object that authorizes requests with bearer tokens.\n// cred: an azcore.TokenCredential implementation such as a credential object from azidentity\n// scopes: the list of permission scopes required for the token.\n// opts: optional settings. Pass nil to accept default values; this is the same as passing a zero-value options.\nfunc NewBearerTokenPolicy(cred exported.TokenCredential, scopes []string, opts *policy.BearerTokenOptions) *BearerTokenPolicy {\n\tif opts == nil {\n\t\topts = &policy.BearerTokenOptions{}\n\t}\n\tah := opts.AuthorizationHandler\n\tif ah.OnRequest == nil {\n\t\t// Set a default OnRequest that simply requests a token with the given scopes. OnChallenge\n\t\t// doesn't get a default so the policy can use a nil check to determine whether the caller\n\t\t// provided an implementation.\n\t\tah.OnRequest = func(_ *policy.Request, authNZ func(policy.TokenRequestOptions) error) error {\n\t\t\t// authNZ sets EnableCAE: true in all cases, no need to duplicate that here\n\t\t\treturn authNZ(policy.TokenRequestOptions{Scopes: scopes})\n\t\t}\n\t}\n\tmr := temporal.NewResourceWithOptions(acquire, temporal.ResourceOptions[exported.AccessToken, acquiringResourceState]{\n\t\tShouldRefresh: shouldRefresh,\n\t})\n\treturn &BearerTokenPolicy{\n\t\tauthzHandler: ah,\n\t\tcred: cred,\n\t\tscopes: scopes,\n\t\tmainResource: mr,\n\t\tallowHTTP: opts.InsecureAllowCredentialWithHTTP,\n\t}\n}\n\n// authenticateAndAuthorize returns a function which authorizes req with a token from the policy's credential\nfunc (b *BearerTokenPolicy) authenticateAndAuthorize(req *policy.Request) func(policy.TokenRequestOptions) error {\n\treturn func(tro policy.TokenRequestOptions) error {\n\t\ttro.EnableCAE = true\n\t\tas := acquiringResourceState{p: b, req: req, tro: tro}\n\t\ttk, err := b.mainResource.Get(as)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treq.Raw().Header.Set(shared.HeaderAuthorization, shared.BearerTokenPrefix+tk.Token)\n\t\treturn nil\n\t}\n}\n\n// Do authorizes a request with a bearer token\nfunc (b *BearerTokenPolicy) Do(req *policy.Request) (*http.Response, error) {\n\t// skip adding the authorization header if no TokenCredential was provided.\n\t// this prevents a panic that might be hard to diagnose and allows testing\n\t// against http endpoints that don't require authentication.\n\tif b.cred == nil {\n\t\treturn req.Next()\n\t}\n\n\tif err := checkHTTPSForAuth(req, b.allowHTTP); err != nil {\n\t\treturn nil, err\n\t}\n\n\terr := b.authzHandler.OnRequest(req, b.authenticateAndAuthorize(req))\n\tif err != nil {\n\t\treturn nil, errorinfo.NonRetriableError(err)\n\t}\n\n\tres, err := req.Next()\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tres, err = b.handleChallenge(req, res, false)\n\treturn res, err\n}\n\n// handleChallenge handles authentication challenges either directly (for CAE challenges) or by calling\n// the AuthorizationHandler. It's a no-op when the response doesn't include an authentication challenge.\n// It will recurse at most once, to handle a CAE challenge following a non-CAE challenge handled by the\n// AuthorizationHandler.\nfunc (b *BearerTokenPolicy) handleChallenge(req *policy.Request, res *http.Response, recursed bool) (*http.Response, error) {\n\tvar err error\n\tif res.StatusCode == http.StatusUnauthorized {\n\t\tb.mainResource.Expire()\n\t\tif res.Header.Get(shared.HeaderWWWAuthenticate) != \"\" {\n\t\t\tcaeChallenge, parseErr := parseCAEChallenge(res)\n\t\t\tif parseErr != nil {\n\t\t\t\treturn res, parseErr\n\t\t\t}\n\t\t\tswitch {\n\t\t\tcase caeChallenge != nil:\n\t\t\t\tauthNZ := func(tro policy.TokenRequestOptions) error {\n\t\t\t\t\t// Take the TokenRequestOptions provided by OnRequest and add the challenge claims. The value\n\t\t\t\t\t// will be empty at time of writing because CAE is the only feature involving claims. If in\n\t\t\t\t\t// the future some client needs to specify unrelated claims, this function may need to merge\n\t\t\t\t\t// them with the challenge claims.\n\t\t\t\t\ttro.Claims = caeChallenge.params[\"claims\"]\n\t\t\t\t\treturn b.authenticateAndAuthorize(req)(tro)\n\t\t\t\t}\n\t\t\t\tif err = b.authzHandler.OnRequest(req, authNZ); err == nil {\n\t\t\t\t\tif err = req.RewindBody(); err == nil {\n\t\t\t\t\t\tres, err = req.Next()\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\tcase b.authzHandler.OnChallenge != nil && !recursed:\n\t\t\t\tif err = b.authzHandler.OnChallenge(req, res, b.authenticateAndAuthorize(req)); err == nil {\n\t\t\t\t\tif err = req.RewindBody(); err == nil {\n\t\t\t\t\t\tif res, err = req.Next(); err == nil {\n\t\t\t\t\t\t\tres, err = b.handleChallenge(req, res, true)\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\t// don't retry challenge handling errors\n\t\t\t\t\terr = errorinfo.NonRetriableError(err)\n\t\t\t\t}\n\t\t\tdefault:\n\t\t\t\t// return the response to the pipeline\n\t\t\t}\n\t\t}\n\t}\n\treturn res, err\n}\n\nfunc checkHTTPSForAuth(req *policy.Request, allowHTTP bool) error {\n\tif strings.ToLower(req.Raw().URL.Scheme) != \"https\" && !allowHTTP {\n\t\treturn errorinfo.NonRetriableError(errors.New(\"authenticated requests are not permitted for non TLS protected (https) endpoints\"))\n\t}\n\treturn nil\n}\n\n// parseCAEChallenge returns a *authChallenge representing Response's CAE challenge (nil when Response has none).\n// If Response includes a CAE challenge having invalid claims, it returns a NonRetriableError.\nfunc parseCAEChallenge(res *http.Response) (*authChallenge, error) {\n\tvar (\n\t\tcaeChallenge *authChallenge\n\t\terr error\n\t)\n\tfor _, c := range parseChallenges(res) {\n\t\tif c.scheme == \"Bearer\" {\n\t\t\tif claims := c.params[\"claims\"]; claims != \"\" && c.params[\"error\"] == \"insufficient_claims\" {\n\t\t\t\tif b, de := base64.StdEncoding.DecodeString(claims); de == nil {\n\t\t\t\t\tc.params[\"claims\"] = string(b)\n\t\t\t\t\tcaeChallenge = &c\n\t\t\t\t} else {\n\t\t\t\t\t// don't include the decoding error because it's something\n\t\t\t\t\t// unhelpful like \"illegal base64 data at input byte 42\"\n\t\t\t\t\terr = errorinfo.NonRetriableError(errors.New(\"authentication challenge contains invalid claims: \" + claims))\n\t\t\t\t}\n\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t}\n\treturn caeChallenge, err\n}\n\nvar (\n\tchallenge, challengeParams *regexp.Regexp\n\tonce = &sync.Once{}\n)\n\ntype authChallenge struct {\n\tscheme string\n\tparams map[string]string\n}\n\n// parseChallenges assumes authentication challenges have quoted parameter values\nfunc parseChallenges(res *http.Response) []authChallenge {\n\tonce.Do(func() {\n\t\t// matches challenges having quoted parameters, capturing scheme and parameters\n\t\tchallenge = regexp.MustCompile(`(?:(\\w+) ((?:\\w+=\"[^\"]*\",?\\s*)+))`)\n\t\t// captures parameter names and values in a match of the above expression\n\t\tchallengeParams = regexp.MustCompile(`(\\w+)=\"([^\"]*)\"`)\n\t})\n\tparsed := []authChallenge{}\n\t// WWW-Authenticate can have multiple values, each containing multiple challenges\n\tfor _, h := range res.Header.Values(shared.HeaderWWWAuthenticate) {\n\t\tfor _, sm := range challenge.FindAllStringSubmatch(h, -1) {\n\t\t\t// sm is [challenge, scheme, params] (see regexp documentation on submatches)\n\t\t\tc := authChallenge{\n\t\t\t\tparams: make(map[string]string),\n\t\t\t\tscheme: sm[1],\n\t\t\t}\n\t\t\tfor _, sm := range challengeParams.FindAllStringSubmatch(sm[2], -1) {\n\t\t\t\t// sm is [key=\"value\", key, value] (see regexp documentation on submatches)\n\t\t\t\tc.params[sm[1]] = sm[2]\n\t\t\t}\n\t\t\tparsed = append(parsed, c)\n\t\t}\n\t}\n\treturn parsed\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/policy_body_download.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage runtime\n\nimport (\n\t\"fmt\"\n\t\"net/http\"\n\t\"strings\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/errorinfo\"\n)\n\n// bodyDownloadPolicy creates a policy object that downloads the response's body to a []byte.\nfunc bodyDownloadPolicy(req *policy.Request) (*http.Response, error) {\n\tresp, err := req.Next()\n\tif err != nil {\n\t\treturn resp, err\n\t}\n\tvar opValues bodyDownloadPolicyOpValues\n\t// don't skip downloading error response bodies\n\tif req.OperationValue(&opValues); opValues.Skip && resp.StatusCode < 400 {\n\t\treturn resp, err\n\t}\n\t// Either bodyDownloadPolicyOpValues was not specified (so skip is false)\n\t// or it was specified and skip is false: don't skip downloading the body\n\t_, err = Payload(resp)\n\tif err != nil {\n\t\treturn resp, newBodyDownloadError(err, req)\n\t}\n\treturn resp, err\n}\n\n// bodyDownloadPolicyOpValues is the struct containing the per-operation values\ntype bodyDownloadPolicyOpValues struct {\n\tSkip bool\n}\n\ntype bodyDownloadError struct {\n\terr error\n}\n\nfunc newBodyDownloadError(err error, req *policy.Request) error {\n\t// on failure, only retry the request for idempotent operations.\n\t// we currently identify them as DELETE, GET, and PUT requests.\n\tif m := strings.ToUpper(req.Raw().Method); m == http.MethodDelete || m == http.MethodGet || m == http.MethodPut {\n\t\t// error is safe for retry\n\t\treturn err\n\t}\n\t// wrap error to avoid retries\n\treturn &bodyDownloadError{\n\t\terr: err,\n\t}\n}\n\nfunc (b *bodyDownloadError) Error() string {\n\treturn fmt.Sprintf(\"body download policy: %s\", b.err.Error())\n}\n\nfunc (b *bodyDownloadError) NonRetriable() {\n\t// marker method\n}\n\nfunc (b *bodyDownloadError) Unwrap() error {\n\treturn b.err\n}\n\nvar _ errorinfo.NonRetriable = (*bodyDownloadError)(nil)\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/policy_http_header.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage runtime\n\nimport (\n\t\"context\"\n\t\"net/http\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy\"\n)\n\n// newHTTPHeaderPolicy creates a policy object that adds custom HTTP headers to a request\nfunc httpHeaderPolicy(req *policy.Request) (*http.Response, error) {\n\t// check if any custom HTTP headers have been specified\n\tif header := req.Raw().Context().Value(shared.CtxWithHTTPHeaderKey{}); header != nil {\n\t\tfor k, v := range header.(http.Header) {\n\t\t\t// use Set to replace any existing value\n\t\t\t// it also canonicalizes the header key\n\t\t\treq.Raw().Header.Set(k, v[0])\n\t\t\t// add any remaining values\n\t\t\tfor i := 1; i < len(v); i++ {\n\t\t\t\treq.Raw().Header.Add(k, v[i])\n\t\t\t}\n\t\t}\n\t}\n\treturn req.Next()\n}\n\n// WithHTTPHeader adds the specified http.Header to the parent context.\n// Use this to specify custom HTTP headers at the API-call level.\n// Any overlapping headers will have their values replaced with the values specified here.\n// Deprecated: use [policy.WithHTTPHeader] instead.\nfunc WithHTTPHeader(parent context.Context, header http.Header) context.Context {\n\treturn policy.WithHTTPHeader(parent, header)\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/policy_http_trace.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage runtime\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"net/url\"\n\t\"strings\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/tracing\"\n)\n\nconst (\n\tattrHTTPMethod = \"http.method\"\n\tattrHTTPURL = \"http.url\"\n\tattrHTTPUserAgent = \"http.user_agent\"\n\tattrHTTPStatusCode = \"http.status_code\"\n\n\tattrAZClientReqID = \"az.client_request_id\"\n\tattrAZServiceReqID = \"az.service_request_id\"\n\n\tattrNetPeerName = \"net.peer.name\"\n)\n\n// newHTTPTracePolicy creates a new instance of the httpTracePolicy.\n// - allowedQueryParams contains the user-specified query parameters that don't need to be redacted from the trace\nfunc newHTTPTracePolicy(allowedQueryParams []string) exported.Policy {\n\treturn &httpTracePolicy{allowedQP: getAllowedQueryParams(allowedQueryParams)}\n}\n\n// httpTracePolicy is a policy that creates a trace for the HTTP request and its response\ntype httpTracePolicy struct {\n\tallowedQP map[string]struct{}\n}\n\n// Do implements the pipeline.Policy interfaces for the httpTracePolicy type.\nfunc (h *httpTracePolicy) Do(req *policy.Request) (resp *http.Response, err error) {\n\trawTracer := req.Raw().Context().Value(shared.CtxWithTracingTracer{})\n\tif tracer, ok := rawTracer.(tracing.Tracer); ok && tracer.Enabled() {\n\t\tattributes := []tracing.Attribute{\n\t\t\t{Key: attrHTTPMethod, Value: req.Raw().Method},\n\t\t\t{Key: attrHTTPURL, Value: getSanitizedURL(*req.Raw().URL, h.allowedQP)},\n\t\t\t{Key: attrNetPeerName, Value: req.Raw().URL.Host},\n\t\t}\n\n\t\tif ua := req.Raw().Header.Get(shared.HeaderUserAgent); ua != \"\" {\n\t\t\tattributes = append(attributes, tracing.Attribute{Key: attrHTTPUserAgent, Value: ua})\n\t\t}\n\t\tif reqID := req.Raw().Header.Get(shared.HeaderXMSClientRequestID); reqID != \"\" {\n\t\t\tattributes = append(attributes, tracing.Attribute{Key: attrAZClientReqID, Value: reqID})\n\t\t}\n\n\t\tctx := req.Raw().Context()\n\t\tctx, span := tracer.Start(ctx, \"HTTP \"+req.Raw().Method, &tracing.SpanOptions{\n\t\t\tKind: tracing.SpanKindClient,\n\t\t\tAttributes: attributes,\n\t\t})\n\n\t\tdefer func() {\n\t\t\tif resp != nil {\n\t\t\t\tspan.SetAttributes(tracing.Attribute{Key: attrHTTPStatusCode, Value: resp.StatusCode})\n\t\t\t\tif resp.StatusCode > 399 {\n\t\t\t\t\tspan.SetStatus(tracing.SpanStatusError, resp.Status)\n\t\t\t\t}\n\t\t\t\tif reqID := resp.Header.Get(shared.HeaderXMSRequestID); reqID != \"\" {\n\t\t\t\t\tspan.SetAttributes(tracing.Attribute{Key: attrAZServiceReqID, Value: reqID})\n\t\t\t\t}\n\t\t\t} else if err != nil {\n\t\t\t\tvar urlErr *url.Error\n\t\t\t\tif errors.As(err, &urlErr) {\n\t\t\t\t\t// calling *url.Error.Error() will include the unsanitized URL\n\t\t\t\t\t// which we don't want. in addition, we already have the HTTP verb\n\t\t\t\t\t// and sanitized URL in the trace so we aren't losing any info\n\t\t\t\t\terr = urlErr.Err\n\t\t\t\t}\n\t\t\t\tspan.SetStatus(tracing.SpanStatusError, err.Error())\n\t\t\t}\n\t\t\tspan.End()\n\t\t}()\n\n\t\treq = req.WithContext(ctx)\n\t}\n\tresp, err = req.Next()\n\treturn\n}\n\n// StartSpanOptions contains the optional values for StartSpan.\ntype StartSpanOptions struct {\n\t// Kind indicates the kind of Span.\n\tKind tracing.SpanKind\n\t// Attributes contains key-value pairs of attributes for the span.\n\tAttributes []tracing.Attribute\n}\n\n// StartSpan starts a new tracing span.\n// You must call the returned func to terminate the span. Pass the applicable error\n// if the span will exit with an error condition.\n// - ctx is the parent context of the newly created context\n// - name is the name of the span. this is typically the fully qualified name of an API (\"Client.Method\")\n// - tracer is the client's Tracer for creating spans\n// - options contains optional values. pass nil to accept any default values\nfunc StartSpan(ctx context.Context, name string, tracer tracing.Tracer, options *StartSpanOptions) (context.Context, func(error)) {\n\tif !tracer.Enabled() {\n\t\treturn ctx, func(err error) {}\n\t}\n\n\t// we MUST propagate the active tracer before returning so that the trace policy can access it\n\tctx = context.WithValue(ctx, shared.CtxWithTracingTracer{}, tracer)\n\n\tif activeSpan := ctx.Value(ctxActiveSpan{}); activeSpan != nil {\n\t\t// per the design guidelines, if a SDK method Foo() calls SDK method Bar(),\n\t\t// then the span for Bar() must be suppressed. however, if Bar() makes a REST\n\t\t// call, then Bar's HTTP span must be a child of Foo's span.\n\t\t// however, there is an exception to this rule. if the SDK method Foo() is a\n\t\t// messaging producer/consumer, and it takes a callback that's a SDK method\n\t\t// Bar(), then the span for Bar() must _not_ be suppressed.\n\t\tif kind := activeSpan.(tracing.SpanKind); kind == tracing.SpanKindClient || kind == tracing.SpanKindInternal {\n\t\t\treturn ctx, func(err error) {}\n\t\t}\n\t}\n\n\tif options == nil {\n\t\toptions = &StartSpanOptions{}\n\t}\n\tif options.Kind == 0 {\n\t\toptions.Kind = tracing.SpanKindInternal\n\t}\n\n\tctx, span := tracer.Start(ctx, name, &tracing.SpanOptions{\n\t\tKind: options.Kind,\n\t\tAttributes: options.Attributes,\n\t})\n\tctx = context.WithValue(ctx, ctxActiveSpan{}, options.Kind)\n\treturn ctx, func(err error) {\n\t\tif err != nil {\n\t\t\terrType := strings.Replace(fmt.Sprintf(\"%T\", err), \"*exported.\", \"*azcore.\", 1)\n\t\t\tspan.SetStatus(tracing.SpanStatusError, fmt.Sprintf(\"%s:\\n%s\", errType, err.Error()))\n\t\t}\n\t\tspan.End()\n\t}\n}\n\n// ctxActiveSpan is used as a context key for indicating a SDK client span is in progress.\ntype ctxActiveSpan struct{}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/policy_include_response.go",
"content": "//go:build go1.16\n// +build go1.16\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage runtime\n\nimport (\n\t\"context\"\n\t\"net/http\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy\"\n)\n\n// includeResponsePolicy creates a policy that retrieves the raw HTTP response upon request\nfunc includeResponsePolicy(req *policy.Request) (*http.Response, error) {\n\tresp, err := req.Next()\n\tif resp == nil {\n\t\treturn resp, err\n\t}\n\tif httpOutRaw := req.Raw().Context().Value(shared.CtxWithCaptureResponse{}); httpOutRaw != nil {\n\t\thttpOut := httpOutRaw.(**http.Response)\n\t\t*httpOut = resp\n\t}\n\treturn resp, err\n}\n\n// WithCaptureResponse applies the HTTP response retrieval annotation to the parent context.\n// The resp parameter will contain the HTTP response after the request has completed.\n// Deprecated: use [policy.WithCaptureResponse] instead.\nfunc WithCaptureResponse(parent context.Context, resp **http.Response) context.Context {\n\treturn policy.WithCaptureResponse(parent, resp)\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/policy_key_credential.go",
"content": "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage runtime\n\nimport (\n\t\"net/http\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/exported\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy\"\n)\n\n// KeyCredentialPolicy authorizes requests with a [azcore.KeyCredential].\ntype KeyCredentialPolicy struct {\n\tcred *exported.KeyCredential\n\theader string\n\tprefix string\n\tallowHTTP bool\n}\n\n// KeyCredentialPolicyOptions contains the optional values configuring [KeyCredentialPolicy].\ntype KeyCredentialPolicyOptions struct {\n\t// InsecureAllowCredentialWithHTTP enables authenticated requests over HTTP.\n\t// By default, authenticated requests to an HTTP endpoint are rejected by the client.\n\t// WARNING: setting this to true will allow sending the authentication key in clear text. Use with caution.\n\tInsecureAllowCredentialWithHTTP bool\n\n\t// Prefix is used if the key requires a prefix before it's inserted into the HTTP request.\n\tPrefix string\n}\n\n// NewKeyCredentialPolicy creates a new instance of [KeyCredentialPolicy].\n// - cred is the [azcore.KeyCredential] used to authenticate with the service\n// - header is the name of the HTTP request header in which the key is placed\n// - options contains optional configuration, pass nil to accept the default values\nfunc NewKeyCredentialPolicy(cred *exported.KeyCredential, header string, options *KeyCredentialPolicyOptions) *KeyCredentialPolicy {\n\tif options == nil {\n\t\toptions = &KeyCredentialPolicyOptions{}\n\t}\n\treturn &KeyCredentialPolicy{\n\t\tcred: cred,\n\t\theader: header,\n\t\tprefix: options.Prefix,\n\t\tallowHTTP: options.InsecureAllowCredentialWithHTTP,\n\t}\n}\n\n// Do implementes the Do method on the [policy.Polilcy] interface.\nfunc (k *KeyCredentialPolicy) Do(req *policy.Request) (*http.Response, error) {\n\t// skip adding the authorization header if no KeyCredential was provided.\n\t// this prevents a panic that might be hard to diagnose and allows testing\n\t// against http endpoints that don't require authentication.\n\tif k.cred != nil {\n\t\tif err := checkHTTPSForAuth(req, k.allowHTTP); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tval := exported.KeyCredentialGet(k.cred)\n\t\tif k.prefix != \"\" {\n\t\t\tval = k.prefix + val\n\t\t}\n\t\treq.Raw().Header.Add(k.header, val)\n\t}\n\treturn req.Next()\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/policy_logging.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage runtime\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n\t\"net/url\"\n\t\"sort\"\n\t\"strings\"\n\t\"time\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/log\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/diag\"\n)\n\ntype logPolicy struct {\n\tincludeBody bool\n\tallowedHeaders map[string]struct{}\n\tallowedQP map[string]struct{}\n}\n\n// NewLogPolicy creates a request/response logging policy object configured using the specified options.\n// Pass nil to accept the default values; this is the same as passing a zero-value options.\nfunc NewLogPolicy(o *policy.LogOptions) policy.Policy {\n\tif o == nil {\n\t\to = &policy.LogOptions{}\n\t}\n\t// construct default hash set of allowed headers\n\tallowedHeaders := map[string]struct{}{\n\t\t\"accept\": {},\n\t\t\"cache-control\": {},\n\t\t\"connection\": {},\n\t\t\"content-length\": {},\n\t\t\"content-type\": {},\n\t\t\"date\": {},\n\t\t\"etag\": {},\n\t\t\"expires\": {},\n\t\t\"if-match\": {},\n\t\t\"if-modified-since\": {},\n\t\t\"if-none-match\": {},\n\t\t\"if-unmodified-since\": {},\n\t\t\"last-modified\": {},\n\t\t\"ms-cv\": {},\n\t\t\"pragma\": {},\n\t\t\"request-id\": {},\n\t\t\"retry-after\": {},\n\t\t\"server\": {},\n\t\t\"traceparent\": {},\n\t\t\"transfer-encoding\": {},\n\t\t\"user-agent\": {},\n\t\t\"www-authenticate\": {},\n\t\t\"x-ms-request-id\": {},\n\t\t\"x-ms-client-request-id\": {},\n\t\t\"x-ms-return-client-request-id\": {},\n\t}\n\t// add any caller-specified allowed headers to the set\n\tfor _, ah := range o.AllowedHeaders {\n\t\tallowedHeaders[strings.ToLower(ah)] = struct{}{}\n\t}\n\t// now do the same thing for query params\n\tallowedQP := getAllowedQueryParams(o.AllowedQueryParams)\n\treturn &logPolicy{\n\t\tincludeBody: o.IncludeBody,\n\t\tallowedHeaders: allowedHeaders,\n\t\tallowedQP: allowedQP,\n\t}\n}\n\n// getAllowedQueryParams merges the default set of allowed query parameters\n// with a custom set (usually comes from client options).\nfunc getAllowedQueryParams(customAllowedQP []string) map[string]struct{} {\n\tallowedQP := map[string]struct{}{\n\t\t\"api-version\": {},\n\t}\n\tfor _, qp := range customAllowedQP {\n\t\tallowedQP[strings.ToLower(qp)] = struct{}{}\n\t}\n\treturn allowedQP\n}\n\n// logPolicyOpValues is the struct containing the per-operation values\ntype logPolicyOpValues struct {\n\ttry int32\n\tstart time.Time\n}\n\nfunc (p *logPolicy) Do(req *policy.Request) (*http.Response, error) {\n\t// Get the per-operation values. These are saved in the Message's map so that they persist across each retry calling into this policy object.\n\tvar opValues logPolicyOpValues\n\tif req.OperationValue(&opValues); opValues.start.IsZero() {\n\t\topValues.start = time.Now() // If this is the 1st try, record this operation's start time\n\t}\n\topValues.try++ // The first try is #1 (not #0)\n\treq.SetOperationValue(opValues)\n\n\t// Log the outgoing request as informational\n\tif log.Should(log.EventRequest) {\n\t\tb := &bytes.Buffer{}\n\t\tfmt.Fprintf(b, \"==> OUTGOING REQUEST (Try=%d)\\n\", opValues.try)\n\t\tp.writeRequestWithResponse(b, req, nil, nil)\n\t\tvar err error\n\t\tif p.includeBody {\n\t\t\terr = writeReqBody(req, b)\n\t\t}\n\t\tlog.Write(log.EventRequest, b.String())\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\n\t// Set the time for this particular retry operation and then Do the operation.\n\ttryStart := time.Now()\n\tresponse, err := req.Next() // Make the request\n\ttryEnd := time.Now()\n\ttryDuration := tryEnd.Sub(tryStart)\n\topDuration := tryEnd.Sub(opValues.start)\n\n\tif log.Should(log.EventResponse) {\n\t\t// We're going to log this; build the string to log\n\t\tb := &bytes.Buffer{}\n\t\tfmt.Fprintf(b, \"==> REQUEST/RESPONSE (Try=%d/%v, OpTime=%v) -- \", opValues.try, tryDuration, opDuration)\n\t\tif err != nil { // This HTTP request did not get a response from the service\n\t\t\tfmt.Fprint(b, \"REQUEST ERROR\\n\")\n\t\t} else {\n\t\t\tfmt.Fprint(b, \"RESPONSE RECEIVED\\n\")\n\t\t}\n\n\t\tp.writeRequestWithResponse(b, req, response, err)\n\t\tif err != nil {\n\t\t\t// skip frames runtime.Callers() and runtime.StackTrace()\n\t\t\tb.WriteString(diag.StackTrace(2, 32))\n\t\t} else if p.includeBody {\n\t\t\terr = writeRespBody(response, b)\n\t\t}\n\t\tlog.Write(log.EventResponse, b.String())\n\t}\n\treturn response, err\n}\n\nconst redactedValue = \"REDACTED\"\n\n// getSanitizedURL returns a sanitized string for the provided url.URL\nfunc getSanitizedURL(u url.URL, allowedQueryParams map[string]struct{}) string {\n\t// redact applicable query params\n\tqp := u.Query()\n\tfor k := range qp {\n\t\tif _, ok := allowedQueryParams[strings.ToLower(k)]; !ok {\n\t\t\tqp.Set(k, redactedValue)\n\t\t}\n\t}\n\tu.RawQuery = qp.Encode()\n\treturn u.String()\n}\n\n// writeRequestWithResponse appends a formatted HTTP request into a Buffer. If request and/or err are\n// not nil, then these are also written into the Buffer.\nfunc (p *logPolicy) writeRequestWithResponse(b *bytes.Buffer, req *policy.Request, resp *http.Response, err error) {\n\t// Write the request into the buffer.\n\tfmt.Fprint(b, \" \"+req.Raw().Method+\" \"+getSanitizedURL(*req.Raw().URL, p.allowedQP)+\"\\n\")\n\tp.writeHeader(b, req.Raw().Header)\n\tif resp != nil {\n\t\tfmt.Fprintln(b, \" --------------------------------------------------------------------------------\")\n\t\tfmt.Fprint(b, \" RESPONSE Status: \"+resp.Status+\"\\n\")\n\t\tp.writeHeader(b, resp.Header)\n\t}\n\tif err != nil {\n\t\tfmt.Fprintln(b, \" --------------------------------------------------------------------------------\")\n\t\tfmt.Fprint(b, \" ERROR:\\n\"+err.Error()+\"\\n\")\n\t}\n}\n\n// formatHeaders appends an HTTP request's or response's header into a Buffer.\nfunc (p *logPolicy) writeHeader(b *bytes.Buffer, header http.Header) {\n\tif len(header) == 0 {\n\t\tb.WriteString(\" (no headers)\\n\")\n\t\treturn\n\t}\n\tkeys := make([]string, 0, len(header))\n\t// Alphabetize the headers\n\tfor k := range header {\n\t\tkeys = append(keys, k)\n\t}\n\tsort.Strings(keys)\n\tfor _, k := range keys {\n\t\t// don't use Get() as it will canonicalize k which might cause a mismatch\n\t\tvalue := header[k][0]\n\t\t// redact all header values not in the allow-list\n\t\tif _, ok := p.allowedHeaders[strings.ToLower(k)]; !ok {\n\t\t\tvalue = redactedValue\n\t\t}\n\t\tfmt.Fprintf(b, \" %s: %+v\\n\", k, value)\n\t}\n}\n\n// returns true if the request/response body should be logged.\n// this is determined by looking at the content-type header value.\nfunc shouldLogBody(b *bytes.Buffer, contentType string) bool {\n\tcontentType = strings.ToLower(contentType)\n\tif strings.HasPrefix(contentType, \"text\") ||\n\t\tstrings.Contains(contentType, \"json\") ||\n\t\tstrings.Contains(contentType, \"xml\") {\n\t\treturn true\n\t}\n\tfmt.Fprintf(b, \" Skip logging body for %s\\n\", contentType)\n\treturn false\n}\n\n// writes to a buffer, used for logging purposes\nfunc writeReqBody(req *policy.Request, b *bytes.Buffer) error {\n\tif req.Raw().Body == nil {\n\t\tfmt.Fprint(b, \" Request contained no body\\n\")\n\t\treturn nil\n\t}\n\tif ct := req.Raw().Header.Get(shared.HeaderContentType); !shouldLogBody(b, ct) {\n\t\treturn nil\n\t}\n\tbody, err := io.ReadAll(req.Raw().Body)\n\tif err != nil {\n\t\tfmt.Fprintf(b, \" Failed to read request body: %s\\n\", err.Error())\n\t\treturn err\n\t}\n\tif err := req.RewindBody(); err != nil {\n\t\treturn err\n\t}\n\tlogBody(b, body)\n\treturn nil\n}\n\n// writes to a buffer, used for logging purposes\nfunc writeRespBody(resp *http.Response, b *bytes.Buffer) error {\n\tct := resp.Header.Get(shared.HeaderContentType)\n\tif ct == \"\" {\n\t\tfmt.Fprint(b, \" Response contained no body\\n\")\n\t\treturn nil\n\t} else if !shouldLogBody(b, ct) {\n\t\treturn nil\n\t}\n\tbody, err := Payload(resp)\n\tif err != nil {\n\t\tfmt.Fprintf(b, \" Failed to read response body: %s\\n\", err.Error())\n\t\treturn err\n\t}\n\tif len(body) > 0 {\n\t\tlogBody(b, body)\n\t} else {\n\t\tfmt.Fprint(b, \" Response contained no body\\n\")\n\t}\n\treturn nil\n}\n\nfunc logBody(b *bytes.Buffer, body []byte) {\n\tfmt.Fprintln(b, \" --------------------------------------------------------------------------------\")\n\tfmt.Fprintln(b, string(body))\n\tfmt.Fprintln(b, \" --------------------------------------------------------------------------------\")\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/policy_request_id.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage runtime\n\nimport (\n\t\"net/http\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/uuid\"\n)\n\ntype requestIDPolicy struct{}\n\n// NewRequestIDPolicy returns a policy that add the x-ms-client-request-id header\nfunc NewRequestIDPolicy() policy.Policy {\n\treturn &requestIDPolicy{}\n}\n\nfunc (r *requestIDPolicy) Do(req *policy.Request) (*http.Response, error) {\n\tif req.Raw().Header.Get(shared.HeaderXMSClientRequestID) == \"\" {\n\t\tid, err := uuid.New()\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\treq.Raw().Header.Set(shared.HeaderXMSClientRequestID, id.String())\n\t}\n\n\treturn req.Next()\n}\n"
},
{
"path": "vendor/github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime/policy_retry.go",
"content": "//go:build go1.18\n// +build go1.18\n\n// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\npackage runtime\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"io\"\n\t\"math\"\n\t\"math/rand\"\n\t\"net/http\"\n\t\"time\"\n\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/log\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/internal/shared\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/errorinfo\"\n\t\"github.com/Azure/azure-sdk-for-go/sdk/internal/exported\"\n)\n\nconst (\n\tdefaultMaxRetries = 3\n)\n\nfunc setDefaults(o *policy.RetryOptions) {\n\tif o.MaxRetries == 0 {\n\t\to.MaxRetries = defaultMaxRetries\n\t} else if o.MaxRetries < 0 {\n\t\to.MaxRetries = 0\n\t}\n\n\t// SDK guidelines specify the default MaxRetryDelay is 60 seconds\n\tif o.MaxRetryDelay == 0 {\n\t\to.MaxRetryDelay = 60 * time.Second\n\t} else if o.MaxRetryDelay < 0 {\n\t\t// not really an unlimited cap, but sufficiently large enough to be considered as such\n\t\to.MaxRetryDelay = math.MaxInt64\n\t}\n\tif o.RetryDelay == 0 {\n\t\to.RetryDelay = 800 * time.Millisecond\n\t} else if o.RetryDelay < 0 {\n\t\to.RetryDelay = 0\n\t}\n\tif o.StatusCodes == nil {\n\t\t// NOTE: if you change this list, you MUST update the docs in policy/policy.go\n\t\to.StatusCodes = []int{\n\t\t\thttp.StatusRequestTimeout, // 408\n\t\t\thttp.StatusTooManyRequests, // 429\n\t\t\thttp.StatusInternalServerError, // 500\n\t\t\thttp.StatusBadGateway, // 502\n\t\t\thttp.StatusServiceUnavailable, // 503\n\t\t\thttp.StatusGatewayTimeout, // 504\n\t\t}\n\t}\n}\n\nfunc calcDelay(o policy.RetryOptions, try int32) time.Duration { // try is >=1; never 0\n\t// avoid overflow when shifting left\n\tfactor := time.Duration(math.MaxInt64)\n\tif try < 63 {\n\t\tfactor = time.Duration(int64(1<