status
stringclasses 1
value | repo_name
stringclasses 31
values | repo_url
stringclasses 31
values | issue_id
int64 1
104k
| title
stringlengths 4
369
| body
stringlengths 0
254k
⌀ | issue_url
stringlengths 37
56
| pull_url
stringlengths 37
54
| before_fix_sha
stringlengths 40
40
| after_fix_sha
stringlengths 40
40
| report_datetime
unknown | language
stringclasses 5
values | commit_datetime
unknown | updated_file
stringlengths 4
188
| file_content
stringlengths 0
5.12M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,728 | Zenith: default to use a class instead of top-level functions in Python | ## Summary
Change the `dagger init` template for Python to use a class instead of just functions. Also update documentation snippets to do the same.
## Motivation
In an earlier iteration of Dagger modules, when the concept of objects that contain functions were introduced, the Python SDK kept the convenience of being able to define simple top-level functions, without having to convert into a class. Python allows this by transparently “creating” the object and associate the top-level functions with it, behind the scenes. It provides a nicer experience for simple use cases, where users don’t have to get the name right for the class, since it has to match the module name.
However, you can’t add a description to the main object this way. And over time we’ve added state to object types, and constructors to initialize that state. Using state has become a common pattern, so a user may **quite often need to convert the top-level functions into a class**.
That takes me back to a few years ago, working with React. You used to be able to create components using either a function or a class. Most people prefer the simplicity of functions, but in React, if you reached a point where you needed to access some lifecycle hooks, you’d need to convert the function into a class. I had to do that a lot myself.
I remember the frustration in the community around this, growing as adoption increased[^1]. I’ve found myself doing this in Python a few times too, and I’ve grown concerned that it’ll add some of the same confusion, frustration or just friction for our users.
For this reason, I think we should default to talk about Python SDK modules using the class, instead of top-level functions, in the documentation and examples. It also makes it more consistent with Go and TypeScript.
[^1]: They eventually fixed it by making classes obsolete and have full-featured hooks in functions.
## Deprecation
I have no plans, nor do I suggest, to deprecate top-level functions at this point. They’ll still be available, just more hidden. We’ll revisit at a later time.
\cc @vikram-dagger @jpadams | https://github.com/dagger/dagger/issues/6728 | https://github.com/dagger/dagger/pull/6729 | e64f185334734a37a2f18a95ec3cf21a27e32437 | 4b7ab1e217d1f2da30723905282ba3cf27de8cab | "2024-02-24T00:58:03Z" | go | "2024-02-26T19:06:17Z" | sdk/python/runtime/go.sum | github.com/99designs/gqlgen v0.17.31 h1:VncSQ82VxieHkea8tz11p7h/zSbvHSxSDZfywqWt158=
github.com/99designs/gqlgen v0.17.31/go.mod h1:i4rEatMrzzu6RXaHydq1nmEPZkb3bKQsnxNRHS4DQB4=
github.com/Khan/genqlient v0.6.0 h1:Bwb1170ekuNIVIwTJEqvO8y7RxBxXu639VJOkKSrwAk=
github.com/Khan/genqlient v0.6.0/go.mod h1:rvChwWVTqXhiapdhLDV4bp9tz/Xvtewwkon4DpWWCRM=
github.com/agnivade/levenshtein v1.1.1/go.mod h1:veldBMzWxcCG2ZvUTKD2kJNRdCk5hVbJomOvKkmgYbo=
github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883 h1:bvNMNQO63//z+xNgfBlViaCIJKLlCJ6/fmUseuG0wVQ=
github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8=
github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0/go.mod h1:t2tdKJDJF9BV14lnkjHmOQgcvEKgtqs5a1N3LNdJhGE=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dgryski/trifles v0.0.0-20200323201526-dd97f9abfb48/go.mod h1:if7Fbed8SFyPtHLHbg49SI7NAdJiC5WIA09pe59rfAA=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/vektah/gqlparser/v2 v2.5.6 h1:Ou14T0N1s191eRMZ1gARVqohcbe1e8FrcONScsq8cRU=
github.com/vektah/gqlparser/v2 v2.5.6/go.mod h1:z8xXUff237NntSuH8mLFijZ+1tjV1swDbpDqjJmk6ME=
golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
golang.org/x/sync v0.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ=
golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,728 | Zenith: default to use a class instead of top-level functions in Python | ## Summary
Change the `dagger init` template for Python to use a class instead of just functions. Also update documentation snippets to do the same.
## Motivation
In an earlier iteration of Dagger modules, when the concept of objects that contain functions were introduced, the Python SDK kept the convenience of being able to define simple top-level functions, without having to convert into a class. Python allows this by transparently “creating” the object and associate the top-level functions with it, behind the scenes. It provides a nicer experience for simple use cases, where users don’t have to get the name right for the class, since it has to match the module name.
However, you can’t add a description to the main object this way. And over time we’ve added state to object types, and constructors to initialize that state. Using state has become a common pattern, so a user may **quite often need to convert the top-level functions into a class**.
That takes me back to a few years ago, working with React. You used to be able to create components using either a function or a class. Most people prefer the simplicity of functions, but in React, if you reached a point where you needed to access some lifecycle hooks, you’d need to convert the function into a class. I had to do that a lot myself.
I remember the frustration in the community around this, growing as adoption increased[^1]. I’ve found myself doing this in Python a few times too, and I’ve grown concerned that it’ll add some of the same confusion, frustration or just friction for our users.
For this reason, I think we should default to talk about Python SDK modules using the class, instead of top-level functions, in the documentation and examples. It also makes it more consistent with Go and TypeScript.
[^1]: They eventually fixed it by making classes obsolete and have full-featured hooks in functions.
## Deprecation
I have no plans, nor do I suggest, to deprecate top-level functions at this point. They’ll still be available, just more hidden. We’ll revisit at a later time.
\cc @vikram-dagger @jpadams | https://github.com/dagger/dagger/issues/6728 | https://github.com/dagger/dagger/pull/6729 | e64f185334734a37a2f18a95ec3cf21a27e32437 | 4b7ab1e217d1f2da30723905282ba3cf27de8cab | "2024-02-24T00:58:03Z" | go | "2024-02-26T19:06:17Z" | sdk/python/runtime/main.go | package main
import (
"context"
_ "embed"
"fmt"
"path"
)
func New(
// +optional
sdkSourceDir *Directory,
) *PythonSdk {
return &PythonSdk{
SDKSourceDir: sdkSourceDir,
RequiredPaths: []string{
"**/pyproject.toml",
},
}
}
type PythonSdk struct {
SDKSourceDir *Directory
RequiredPaths []string
}
const (
ModSourceDirPath = "/src"
RuntimeExecutablePath = "/runtime"
venv = "/opt/venv"
sdkSrc = "/sdk"
genDir = "sdk"
genPath = "src/dagger/client/gen.py"
schemaPath = "/schema.json"
defaultPythonVersion = "3.11-slim"
defaultPythonDigest = "sha256:8f64a67710f3d981cf3008d6f9f1dbe61accd7927f165f4e37ea3f8b883ccc3f"
)
//go:embed scripts/runtime.py
var runtimeTmpl string
func (m *PythonSdk) ModuleRuntime(
ctx context.Context,
modSource *ModuleSource,
introspectionJson string,
) (*Container, error) {
ctr, err := m.CodegenBase(ctx, modSource, introspectionJson)
if err != nil {
return nil, err
}
return ctr.
WithExec([]string{"python", "-m", "pip", "install", "."}).
WithNewFile(RuntimeExecutablePath, ContainerWithNewFileOpts{
Contents: runtimeTmpl,
Permissions: 0755,
}).
WithEntrypoint([]string{RuntimeExecutablePath}), nil
}
func (m *PythonSdk) Codegen(ctx context.Context, modSource *ModuleSource, introspectionJson string) (*GeneratedCode, error) {
ctr, err := m.CodegenBase(ctx, modSource, introspectionJson)
if err != nil {
return nil, err
}
ctr = ctr.WithDirectory(genDir, ctr.Directory(sdkSrc), ContainerWithDirectoryOpts{
Exclude: []string{
"**/__pycache__",
},
})
return dag.GeneratedCode(ctr.Directory(ModSourceDirPath)).
WithVCSGeneratedPaths(
[]string{genDir + "/**"},
).
WithVCSIgnoredPaths(
[]string{genDir},
), nil
}
func (m *PythonSdk) CodegenBase(ctx context.Context, modSource *ModuleSource, introspectionJson string) (*Container, error) {
subPath, err := modSource.SourceSubpath(ctx)
if err != nil {
return nil, fmt.Errorf("could not load module config: %v", err)
}
return m.Base("").
WithMountedDirectory(sdkSrc, m.SDKSourceDir.WithoutDirectory("runtime")).
WithMountedDirectory("/opt", dag.CurrentModule().Source().Directory("./template")).
WithExec([]string{"python", "-m", "pip", "install", "-e", sdkSrc}).
WithMountedDirectory(ModSourceDirPath, modSource.ContextDirectory()).
WithWorkdir(path.Join(ModSourceDirPath, subPath)).
WithNewFile(schemaPath, ContainerWithNewFileOpts{
Contents: introspectionJson,
}).
// TODO: Move all of this to a python script, add more intelligence.
WithExec([]string{
"python", "-m", "dagger", "codegen",
"--output", path.Join(sdkSrc, genPath),
"--introspection", schemaPath,
}, ContainerWithExecOpts{
ExperimentalPrivilegedNesting: true,
}).
WithExec([]string{"sh", "-c", "[ -f pyproject.toml ] || cp /opt/pyproject.toml ."}).
WithExec([]string{"sh", "-c", "find . -name '*.py' | grep -q . || { mkdir -p src; cp /opt/src/main.py src/main.py; }"}), nil
}
func (m *PythonSdk) Base(version string) *Container {
if version == "" {
version = defaultPythonVersion + "@" + defaultPythonDigest
}
return dag.Container().
From("python:"+version).
WithMountedCache("/root/.cache/pip", dag.CacheVolume("modpipcache-"+version)).
WithExec([]string{"python", "-m", "venv", venv}).
WithEnvVariable("VIRTUAL_ENV", venv).
WithEnvVariable("PATH", "$VIRTUAL_ENV/bin:$PATH", ContainerWithEnvVariableOpts{
Expand: true,
})
}
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,728 | Zenith: default to use a class instead of top-level functions in Python | ## Summary
Change the `dagger init` template for Python to use a class instead of just functions. Also update documentation snippets to do the same.
## Motivation
In an earlier iteration of Dagger modules, when the concept of objects that contain functions were introduced, the Python SDK kept the convenience of being able to define simple top-level functions, without having to convert into a class. Python allows this by transparently “creating” the object and associate the top-level functions with it, behind the scenes. It provides a nicer experience for simple use cases, where users don’t have to get the name right for the class, since it has to match the module name.
However, you can’t add a description to the main object this way. And over time we’ve added state to object types, and constructors to initialize that state. Using state has become a common pattern, so a user may **quite often need to convert the top-level functions into a class**.
That takes me back to a few years ago, working with React. You used to be able to create components using either a function or a class. Most people prefer the simplicity of functions, but in React, if you reached a point where you needed to access some lifecycle hooks, you’d need to convert the function into a class. I had to do that a lot myself.
I remember the frustration in the community around this, growing as adoption increased[^1]. I’ve found myself doing this in Python a few times too, and I’ve grown concerned that it’ll add some of the same confusion, frustration or just friction for our users.
For this reason, I think we should default to talk about Python SDK modules using the class, instead of top-level functions, in the documentation and examples. It also makes it more consistent with Go and TypeScript.
[^1]: They eventually fixed it by making classes obsolete and have full-featured hooks in functions.
## Deprecation
I have no plans, nor do I suggest, to deprecate top-level functions at this point. They’ll still be available, just more hidden. We’ll revisit at a later time.
\cc @vikram-dagger @jpadams | https://github.com/dagger/dagger/issues/6728 | https://github.com/dagger/dagger/pull/6729 | e64f185334734a37a2f18a95ec3cf21a27e32437 | 4b7ab1e217d1f2da30723905282ba3cf27de8cab | "2024-02-24T00:58:03Z" | go | "2024-02-26T19:06:17Z" | sdk/python/runtime/template/src/main.py | import dagger
from dagger import dag, function
@function
def container_echo(string_arg: str) -> dagger.Container:
# Example usage: "dagger call container-echo --string-arg hello stdout"
return dag.container().from_("alpine:latest").with_exec(["echo", string_arg])
@function
async def grep_dir(directory_arg: dagger.Directory, pattern: str) -> str:
# Example usage: "dagger call grep-dir --directory-arg . --patern grep_dir"
return await (
dag.container()
.from_("alpine:latest")
.with_mounted_directory("/mnt", directory_arg)
.with_workdir("/mnt")
.with_exec(["grep", "-R", pattern, "."])
.stdout()
)
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,719 | Very high memory usage in dagger engine | I noticed that on `main` when running `go test -run=TestModule ...` the engine ends up using over 6GB of RSS at times. By eye, it seems like it particularly spikes during `TestModuleLotsOfFunctions` (but did not fully confirm yet).
`pprof` is showing:
```
File: dagger-engine
Type: inuse_space
Time: Feb 22, 2024 at 10:18am (PST)
Entering interactive mode (type "help" for commands, "o" for options)
(pprof) top
Showing nodes accounting for 1811.45MB, 71.51% of 2533.09MB total
Dropped 846 nodes (cum <= 12.67MB)
Showing top 10 nodes out of 239
flat flat% sum% cum cum%
622.26MB 24.57% 24.57% 622.26MB 24.57% github.com/moby/buildkit/solver/pb.(*FileActionMkFile).Unmarshal
605.22MB 23.89% 48.46% 605.22MB 23.89% github.com/moby/buildkit/solver/pb.(*Op).Marshal
104.69MB 4.13% 52.59% 104.69MB 4.13% google.golang.org/grpc/internal/transport.newBufWriter
103.08MB 4.07% 56.66% 103.08MB 4.07% encoding/json.(*decodeState).literalStore
90.83MB 3.59% 60.25% 201.88MB 7.97% github.com/dagger/dagger/core.(*ModDeps).lazilyLoadSchema
90.26MB 3.56% 63.81% 90.26MB 3.56% bufio.NewReaderSize
75.57MB 2.98% 66.79% 75.57MB 2.98% google.golang.org/protobuf/internal/impl.consumeStringValidateUTF8
51.02MB 2.01% 68.81% 69.52MB 2.74% google.golang.org/grpc/internal/transport.(*http2Server).operateHeaders
34.51MB 1.36% 70.17% 34.51MB 1.36% github.com/moby/buildkit/client/llb.mergeMetadata
34.02MB 1.34% 71.51% 34.02MB 1.34% github.com/dagger/dagger/dagql.Class[go.shape.*uint8].Install
```
The top memory users seem pretty consistent across two runs.
I can't help but wonder to what extent the goroutine leak as mentioned by @jedevc could be related: https://github.com/dagger/dagger/pull/6597. I.e. the goroutine leak is resulting in memory allocated by the above still be reachable. Just a superficial connection in that goroutine leaks are a very common culprit of memory leaks, could be red herring.
Also wondering if the recent changes to make more [heavy use of caching `OpDAG` modifications](https://github.com/dagger/dagger/pull/6505) could be related, just in that it could be connected to the heavy usage of `Op.Marshal` in the pprof output.
* Can test by going back before that commit and seeing if the memory usage was any different. | https://github.com/dagger/dagger/issues/6719 | https://github.com/dagger/dagger/pull/6760 | f71928d6e4baef0735e06afacdf2772880bf1536 | a0b622addceef9308b75c928935394c976c4872b | "2024-02-22T19:02:08Z" | go | "2024-02-27T19:34:42Z" | engine/server/buildkitcontroller.go | package server
import (
"context"
"errors"
"fmt"
"io"
"runtime"
"runtime/debug"
"sync"
"time"
"github.com/dagger/dagger/auth"
"github.com/dagger/dagger/core"
"github.com/dagger/dagger/core/pipeline"
"github.com/dagger/dagger/engine"
"github.com/dagger/dagger/engine/buildkit"
"github.com/dagger/dagger/engine/cache"
controlapi "github.com/moby/buildkit/api/services/control"
apitypes "github.com/moby/buildkit/api/types"
"github.com/moby/buildkit/cache/remotecache"
bkclient "github.com/moby/buildkit/client"
"github.com/moby/buildkit/executor/oci"
"github.com/moby/buildkit/frontend"
bkgw "github.com/moby/buildkit/frontend/gateway/client"
"github.com/moby/buildkit/identity"
"github.com/moby/buildkit/session"
"github.com/moby/buildkit/session/grpchijack"
containerdsnapshot "github.com/moby/buildkit/snapshot/containerd"
"github.com/moby/buildkit/solver"
"github.com/moby/buildkit/solver/llbsolver"
"github.com/moby/buildkit/solver/pb"
"github.com/moby/buildkit/util/bklog"
"github.com/moby/buildkit/util/entitlements"
"github.com/moby/buildkit/util/imageutil"
"github.com/moby/buildkit/util/leaseutil"
"github.com/moby/buildkit/util/throttle"
"github.com/moby/buildkit/util/tracing/transform"
bkworker "github.com/moby/buildkit/worker"
"github.com/moby/locker"
"github.com/sirupsen/logrus"
"go.opentelemetry.io/otel/sdk/trace"
tracev1 "go.opentelemetry.io/proto/otlp/collector/trace/v1"
"golang.org/x/sync/errgroup"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
type BuildkitController struct {
BuildkitControllerOpts
*tracev1.UnimplementedTraceServiceServer // needed for grpc service register to not complain
llbSolver *llbsolver.Solver
genericSolver *solver.Solver
cacheManager solver.CacheManager
worker bkworker.Worker
privilegedExecEnabled bool
// server id -> server
servers map[string]*DaggerServer
serverMu sync.RWMutex
perServerMu *locker.Locker
throttledGC func()
gcmu sync.Mutex
}
type BuildkitControllerOpts struct {
WorkerController *bkworker.Controller
SessionManager *session.Manager
CacheManager solver.CacheManager
ContentStore *containerdsnapshot.Store
LeaseManager *leaseutil.Manager
Entitlements []string
EngineName string
Frontends map[string]frontend.Frontend
TraceCollector trace.SpanExporter
UpstreamCacheExporters map[string]remotecache.ResolveCacheExporterFunc
UpstreamCacheImporters map[string]remotecache.ResolveCacheImporterFunc
DNSConfig *oci.DNSConfig
}
func NewBuildkitController(opts BuildkitControllerOpts) (*BuildkitController, error) {
w, err := opts.WorkerController.GetDefault()
if err != nil {
return nil, fmt.Errorf("failed to get default worker: %w", err)
}
llbSolver, err := llbsolver.New(llbsolver.Opt{
WorkerController: opts.WorkerController,
Frontends: opts.Frontends,
CacheManager: opts.CacheManager,
SessionManager: opts.SessionManager,
CacheResolvers: opts.UpstreamCacheImporters,
Entitlements: opts.Entitlements,
})
if err != nil {
return nil, fmt.Errorf("failed to create solver: %w", err)
}
genericSolver := solver.NewSolver(solver.SolverOpt{
ResolveOpFunc: func(vtx solver.Vertex, builder solver.Builder) (solver.Op, error) {
return w.ResolveOp(vtx, llbSolver.Bridge(builder), opts.SessionManager)
},
DefaultCache: opts.CacheManager,
})
e := &BuildkitController{
BuildkitControllerOpts: opts,
llbSolver: llbSolver,
genericSolver: genericSolver,
cacheManager: opts.CacheManager,
worker: w,
servers: make(map[string]*DaggerServer),
perServerMu: locker.New(),
}
for _, entitlementStr := range opts.Entitlements {
if entitlementStr == string(entitlements.EntitlementSecurityInsecure) {
e.privilegedExecEnabled = true
}
}
e.throttledGC = throttle.After(time.Minute, e.gc)
defer func() {
time.AfterFunc(time.Second, e.throttledGC)
}()
return e, nil
}
func (e *BuildkitController) LogMetrics(l *logrus.Entry) *logrus.Entry {
e.serverMu.RLock()
defer e.serverMu.RUnlock()
l = l.WithField("dagger-server-count", len(e.servers))
for _, s := range e.servers {
l = s.LogMetrics(l)
}
return l
}
func (e *BuildkitController) Session(stream controlapi.Control_SessionServer) (rerr error) {
defer func() {
// a panic would indicate a bug, but we don't want to take down the entire server
if err := recover(); err != nil {
bklog.G(context.Background()).WithError(fmt.Errorf("%v", err)).Errorf("panic in session call")
debug.PrintStack()
rerr = fmt.Errorf("panic in session call, please report a bug: %v %s", err, string(debug.Stack()))
}
}()
ctx, cancel := context.WithCancel(stream.Context())
defer cancel()
opts, err := engine.ClientMetadataFromContext(ctx)
if err != nil {
bklog.G(ctx).WithError(err).Errorf("failed to get client metadata for session call")
return fmt.Errorf("failed to get client metadata for session call: %w", err)
}
ctx = bklog.WithLogger(ctx, bklog.G(ctx).
WithField("client_id", opts.ClientID).
WithField("client_hostname", opts.ClientHostname).
WithField("client_call_digest", opts.ModuleCallerDigest).
WithField("server_id", opts.ServerID))
bklog.G(ctx).WithField("register_client", opts.RegisterClient).Debug("handling session call")
defer func() {
if rerr != nil {
bklog.G(ctx).WithError(rerr).Errorf("session call failed")
} else {
bklog.G(ctx).Debugf("session call done")
}
}()
conn, closeCh, hijackmd := grpchijack.Hijack(stream)
// TODO: this blocks if opts.RegisterClient and an error happens
// TODO: ? defer conn.Close()
go func() {
<-closeCh
cancel()
}()
if !opts.RegisterClient {
e.serverMu.RLock()
srv, ok := e.servers[opts.ServerID]
e.serverMu.RUnlock()
if !ok {
return fmt.Errorf("server %q not found", opts.ServerID)
}
err := srv.bkClient.VerifyClient(opts.ClientID, opts.ClientSecretToken)
if err != nil {
return fmt.Errorf("failed to verify client: %w", err)
}
bklog.G(ctx).Debugf("forwarding client to server")
err = srv.ServeClientConn(ctx, opts, conn)
if errors.Is(err, io.ErrClosedPipe) {
return nil
}
return fmt.Errorf("serve clientConn: %w", err)
}
bklog.G(ctx).Debugf("registering client")
eg, egctx := errgroup.WithContext(ctx)
eg.Go(func() error {
bklog.G(ctx).Debug("session manager handling conn")
err := e.SessionManager.HandleConn(egctx, conn, hijackmd)
bklog.G(ctx).WithError(err).Debug("session manager handle conn done")
if err != nil {
return fmt.Errorf("handleConn: %w", err)
}
return nil
})
// NOTE: the perServerMu here is used to ensure that we hold a lock
// specific to only *this server*, so we don't allow creating multiple
// servers with the same ID at once. This complexity is necessary so we
// don't hold the global serverMu lock for longer than necessary.
e.perServerMu.Lock(opts.ServerID)
e.serverMu.RLock()
srv, ok := e.servers[opts.ServerID]
e.serverMu.RUnlock()
if !ok {
bklog.G(ctx).Debugf("initializing new server")
getSessionCtx, getSessionCancel := context.WithTimeout(ctx, 10*time.Second)
defer getSessionCancel()
caller, err := e.SessionManager.Get(getSessionCtx, opts.ClientID, false)
if err != nil {
e.perServerMu.Unlock(opts.ServerID)
return fmt.Errorf("get session: %w", err)
}
bklog.G(ctx).Debugf("connected new server session")
secretStore := core.NewSecretStore()
authProvider := auth.NewRegistryAuthProvider()
var cacheImporterCfgs []bkgw.CacheOptionsEntry
for _, cacheImportCfg := range opts.UpstreamCacheImportConfig {
_, ok := e.UpstreamCacheImporters[cacheImportCfg.Type]
if !ok {
e.perServerMu.Unlock(opts.ServerID)
return fmt.Errorf("unknown cache importer type %q", cacheImportCfg.Type)
}
cacheImporterCfgs = append(cacheImporterCfgs, bkgw.CacheOptionsEntry{
Type: cacheImportCfg.Type,
Attrs: cacheImportCfg.Attrs,
})
}
// using a new random ID rather than server ID to squash any nefarious attempts to set
// a server id that has e.g. ../../.. or similar in it
progSockPath := fmt.Sprintf("/run/dagger/server-progrock-%s.sock", identity.NewID())
bkClient, err := buildkit.NewClient(ctx, buildkit.Opts{
Worker: e.worker,
SessionManager: e.SessionManager,
LLBSolver: e.llbSolver,
GenericSolver: e.genericSolver,
SecretStore: secretStore,
AuthProvider: authProvider,
PrivilegedExecEnabled: e.privilegedExecEnabled,
UpstreamCacheImports: cacheImporterCfgs,
ProgSockPath: progSockPath,
MainClientCaller: caller,
MainClientCallerID: opts.ClientID,
DNSConfig: e.DNSConfig,
Frontends: e.Frontends,
})
if err != nil {
e.perServerMu.Unlock(opts.ServerID)
return fmt.Errorf("new Buildkit client: %w", err)
}
bklog.G(ctx).Debugf("initialized new server buildkit client")
labels := opts.Labels
labels = append(labels, pipeline.EngineLabel(e.EngineName))
labels = append(labels, pipeline.LoadServerLabels(engine.Version, runtime.GOOS, runtime.GOARCH, e.cacheManager.ID() != cache.LocalCacheID)...)
srv, err = NewDaggerServer(ctx, bkClient, e.worker, caller, opts.ServerID, secretStore, authProvider, labels, opts.CloudToken, opts.DoNotTrack)
if err != nil {
e.perServerMu.Unlock(opts.ServerID)
return fmt.Errorf("new Dagger server: %w", err)
}
e.serverMu.Lock()
e.servers[opts.ServerID] = srv
e.serverMu.Unlock()
bklog.G(ctx).Debugf("initialized new server")
// delete the server after the initial client who created it exits
defer func() {
bklog.G(ctx).Debug("removing server")
e.serverMu.Lock()
delete(e.servers, opts.ServerID)
e.serverMu.Unlock()
srv.Close()
if err := bkClient.Close(); err != nil {
bklog.G(ctx).WithError(err).Errorf("failed to close buildkit client for server %s", opts.ServerID)
}
bklog.G(ctx).Debug("closed buildkit client")
time.AfterFunc(time.Second, e.throttledGC)
bklog.G(ctx).Debug("server removed")
}()
}
e.perServerMu.Unlock(opts.ServerID)
err = srv.bkClient.RegisterClient(opts.ClientID, opts.ClientHostname, opts.ClientSecretToken)
if err != nil {
return fmt.Errorf("failed to register client: %w", err)
}
eg.Go(func() error {
bklog.G(ctx).Trace("waiting for server")
err := srv.Wait(egctx)
bklog.G(ctx).WithError(err).Trace("server done")
if err != nil {
return fmt.Errorf("srv.Wait: %w", err)
}
return nil
})
err = eg.Wait()
if errors.Is(err, context.Canceled) {
err = nil
}
if err != nil {
return fmt.Errorf("wait: %w", err)
}
return nil
}
// Solve is currently only used for triggering upstream remote cache exports on a dagger server
func (e *BuildkitController) Solve(ctx context.Context, req *controlapi.SolveRequest) (*controlapi.SolveResponse, error) {
opts, err := engine.ClientMetadataFromContext(ctx)
if err != nil {
return nil, err
}
ctx = bklog.WithLogger(ctx, bklog.G(ctx).
WithField("client_id", opts.ClientID).
WithField("client_hostname", opts.ClientHostname).
WithField("server_id", opts.ServerID))
e.serverMu.RLock()
srv, ok := e.servers[opts.ServerID]
e.serverMu.RUnlock()
if !ok {
return nil, fmt.Errorf("unknown server id %q", opts.ServerID)
}
err = srv.bkClient.VerifyClient(opts.ClientID, opts.ClientSecretToken)
if err != nil {
return nil, fmt.Errorf("failed to register client: %w", err)
}
cacheExporterFuncs := make([]buildkit.ResolveCacheExporterFunc, len(req.Cache.Exports))
for i, cacheExportCfg := range req.Cache.Exports {
cacheExportCfg := cacheExportCfg
exporterFunc, ok := e.UpstreamCacheExporters[cacheExportCfg.Type]
if !ok {
return nil, fmt.Errorf("unknown cache exporter type %q", cacheExportCfg.Type)
}
cacheExporterFuncs[i] = func(ctx context.Context, sessionGroup session.Group) (remotecache.Exporter, error) {
return exporterFunc(ctx, sessionGroup, cacheExportCfg.Attrs)
}
}
if len(cacheExporterFuncs) > 0 {
// run cache export instead
bklog.G(ctx).Debugf("running cache export for client %s", opts.ClientID)
err := srv.bkClient.UpstreamCacheExport(ctx, cacheExporterFuncs)
if err != nil {
bklog.G(ctx).WithError(err).Errorf("error running cache export for client %s", opts.ClientID)
return &controlapi.SolveResponse{}, err
}
bklog.G(ctx).Debugf("done running cache export for client %s", opts.ClientID)
}
return &controlapi.SolveResponse{}, nil
}
func (e *BuildkitController) DiskUsage(ctx context.Context, r *controlapi.DiskUsageRequest) (*controlapi.DiskUsageResponse, error) {
resp := &controlapi.DiskUsageResponse{}
du, err := e.worker.DiskUsage(ctx, bkclient.DiskUsageInfo{
Filter: r.Filter,
})
if err != nil {
return nil, err
}
for _, r := range du {
resp.Record = append(resp.Record, &controlapi.UsageRecord{
ID: r.ID,
Mutable: r.Mutable,
InUse: r.InUse,
Size_: r.Size,
Parents: r.Parents,
UsageCount: int64(r.UsageCount),
Description: r.Description,
CreatedAt: r.CreatedAt,
LastUsedAt: r.LastUsedAt,
RecordType: string(r.RecordType),
Shared: r.Shared,
})
}
return resp, nil
}
func (e *BuildkitController) Prune(req *controlapi.PruneRequest, stream controlapi.Control_PruneServer) error {
eg, ctx := errgroup.WithContext(stream.Context())
e.serverMu.RLock()
cancelLeases := len(e.servers) == 0
e.serverMu.RUnlock()
if cancelLeases {
imageutil.CancelCacheLeases()
}
didPrune := false
defer func() {
if didPrune {
if e, ok := e.cacheManager.(interface {
ReleaseUnreferenced(context.Context) error
}); ok {
if err := e.ReleaseUnreferenced(ctx); err != nil {
bklog.G(ctx).Errorf("failed to release cache metadata: %+v", err)
}
}
}
}()
ch := make(chan bkclient.UsageInfo, 32)
eg.Go(func() error {
defer close(ch)
return e.worker.Prune(ctx, ch, bkclient.PruneInfo{
Filter: req.Filter,
All: req.All,
KeepDuration: time.Duration(req.KeepDuration),
KeepBytes: req.KeepBytes,
})
})
eg.Go(func() error {
defer func() {
// drain channel on error
for range ch {
}
}()
for r := range ch {
didPrune = true
if err := stream.Send(&controlapi.UsageRecord{
ID: r.ID,
Mutable: r.Mutable,
InUse: r.InUse,
Size_: r.Size,
Parents: r.Parents,
UsageCount: int64(r.UsageCount),
Description: r.Description,
CreatedAt: r.CreatedAt,
LastUsedAt: r.LastUsedAt,
RecordType: string(r.RecordType),
Shared: r.Shared,
}); err != nil {
return err
}
}
return nil
})
return eg.Wait()
}
func (e *BuildkitController) Info(ctx context.Context, r *controlapi.InfoRequest) (*controlapi.InfoResponse, error) {
return &controlapi.InfoResponse{
BuildkitVersion: &apitypes.BuildkitVersion{
Package: engine.Package,
Version: engine.Version,
Revision: e.EngineName,
},
}, nil
}
func (e *BuildkitController) ListWorkers(ctx context.Context, r *controlapi.ListWorkersRequest) (*controlapi.ListWorkersResponse, error) {
resp := &controlapi.ListWorkersResponse{
Record: []*apitypes.WorkerRecord{{
ID: e.worker.ID(),
Labels: e.worker.Labels(),
Platforms: pb.PlatformsFromSpec(e.worker.Platforms(true)),
}},
}
return resp, nil
}
func (e *BuildkitController) Export(ctx context.Context, req *tracev1.ExportTraceServiceRequest) (*tracev1.ExportTraceServiceResponse, error) {
if e.TraceCollector == nil {
return nil, status.Errorf(codes.Unavailable, "trace collector not configured")
}
err := e.TraceCollector.ExportSpans(ctx, transform.Spans(req.GetResourceSpans()))
if err != nil {
return nil, err
}
return &tracev1.ExportTraceServiceResponse{}, nil
}
func (e *BuildkitController) Register(server *grpc.Server) {
controlapi.RegisterControlServer(server, e)
tracev1.RegisterTraceServiceServer(server, e)
}
func (e *BuildkitController) Close() error {
err := e.WorkerController.Close()
// note this *could* cause a panic in Session if it was still running, so
// the server should be shutdown first
e.serverMu.Lock()
servers := e.servers
e.servers = nil
e.serverMu.Unlock()
for _, s := range servers {
s.Close()
}
return err
}
func (e *BuildkitController) gc() {
e.gcmu.Lock()
defer e.gcmu.Unlock()
ch := make(chan bkclient.UsageInfo)
eg, ctx := errgroup.WithContext(context.TODO())
var size int64
eg.Go(func() error {
for ui := range ch {
size += ui.Size
}
return nil
})
eg.Go(func() error {
defer close(ch)
if policy := e.worker.GCPolicy(); len(policy) > 0 {
return e.worker.Prune(ctx, ch, policy...)
}
return nil
})
err := eg.Wait()
if err != nil {
bklog.G(ctx).Errorf("gc error: %+v", err)
}
if size > 0 {
bklog.G(ctx).Debugf("gc cleaned up %d bytes", size)
}
}
func (e *BuildkitController) Status(req *controlapi.StatusRequest, stream controlapi.Control_StatusServer) error {
// we send status updates over progrock session attachables instead
return fmt.Errorf("status not implemented")
}
func (e *BuildkitController) ListenBuildHistory(req *controlapi.BuildHistoryRequest, srv controlapi.Control_ListenBuildHistoryServer) error {
return fmt.Errorf("listen build history not implemented")
}
func (e *BuildkitController) UpdateBuildHistory(ctx context.Context, req *controlapi.UpdateBuildHistoryRequest) (*controlapi.UpdateBuildHistoryResponse, error) {
return nil, fmt.Errorf("update build history not implemented")
}
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,719 | Very high memory usage in dagger engine | I noticed that on `main` when running `go test -run=TestModule ...` the engine ends up using over 6GB of RSS at times. By eye, it seems like it particularly spikes during `TestModuleLotsOfFunctions` (but did not fully confirm yet).
`pprof` is showing:
```
File: dagger-engine
Type: inuse_space
Time: Feb 22, 2024 at 10:18am (PST)
Entering interactive mode (type "help" for commands, "o" for options)
(pprof) top
Showing nodes accounting for 1811.45MB, 71.51% of 2533.09MB total
Dropped 846 nodes (cum <= 12.67MB)
Showing top 10 nodes out of 239
flat flat% sum% cum cum%
622.26MB 24.57% 24.57% 622.26MB 24.57% github.com/moby/buildkit/solver/pb.(*FileActionMkFile).Unmarshal
605.22MB 23.89% 48.46% 605.22MB 23.89% github.com/moby/buildkit/solver/pb.(*Op).Marshal
104.69MB 4.13% 52.59% 104.69MB 4.13% google.golang.org/grpc/internal/transport.newBufWriter
103.08MB 4.07% 56.66% 103.08MB 4.07% encoding/json.(*decodeState).literalStore
90.83MB 3.59% 60.25% 201.88MB 7.97% github.com/dagger/dagger/core.(*ModDeps).lazilyLoadSchema
90.26MB 3.56% 63.81% 90.26MB 3.56% bufio.NewReaderSize
75.57MB 2.98% 66.79% 75.57MB 2.98% google.golang.org/protobuf/internal/impl.consumeStringValidateUTF8
51.02MB 2.01% 68.81% 69.52MB 2.74% google.golang.org/grpc/internal/transport.(*http2Server).operateHeaders
34.51MB 1.36% 70.17% 34.51MB 1.36% github.com/moby/buildkit/client/llb.mergeMetadata
34.02MB 1.34% 71.51% 34.02MB 1.34% github.com/dagger/dagger/dagql.Class[go.shape.*uint8].Install
```
The top memory users seem pretty consistent across two runs.
I can't help but wonder to what extent the goroutine leak as mentioned by @jedevc could be related: https://github.com/dagger/dagger/pull/6597. I.e. the goroutine leak is resulting in memory allocated by the above still be reachable. Just a superficial connection in that goroutine leaks are a very common culprit of memory leaks, could be red herring.
Also wondering if the recent changes to make more [heavy use of caching `OpDAG` modifications](https://github.com/dagger/dagger/pull/6505) could be related, just in that it could be connected to the heavy usage of `Op.Marshal` in the pprof output.
* Can test by going back before that commit and seeing if the memory usage was any different. | https://github.com/dagger/dagger/issues/6719 | https://github.com/dagger/dagger/pull/6760 | f71928d6e4baef0735e06afacdf2772880bf1536 | a0b622addceef9308b75c928935394c976c4872b | "2024-02-22T19:02:08Z" | go | "2024-02-27T19:34:42Z" | engine/server/server.go | package server
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"net"
"net/http"
"os"
"sync"
"time"
"github.com/dagger/dagger/analytics"
"github.com/dagger/dagger/auth"
"github.com/dagger/dagger/core"
"github.com/dagger/dagger/core/pipeline"
"github.com/dagger/dagger/core/schema"
"github.com/dagger/dagger/engine"
"github.com/dagger/dagger/engine/buildkit"
bksession "github.com/moby/buildkit/session"
"github.com/moby/buildkit/util/bklog"
bkworker "github.com/moby/buildkit/worker"
"github.com/sirupsen/logrus"
"github.com/vito/progrock"
)
type DaggerServer struct {
serverID string
bkClient *buildkit.Client
worker bkworker.Worker
schema *schema.APIServer
recorder *progrock.Recorder
analytics analytics.Tracker
progCleanup func() error
doneCh chan struct{}
closeOnce sync.Once
connectedClients int
clientMu sync.RWMutex
}
func NewDaggerServer(
ctx context.Context,
bkClient *buildkit.Client,
worker bkworker.Worker,
caller bksession.Caller,
serverID string,
secretStore *core.SecretStore,
authProvider *auth.RegistryAuthProvider,
rootLabels []pipeline.Label,
cloudToken string,
doNotTrack bool,
) (*DaggerServer, error) {
srv := &DaggerServer{
serverID: serverID,
bkClient: bkClient,
worker: worker,
analytics: analytics.New(analytics.Config{
DoNotTrack: doNotTrack || analytics.DoNotTrack(),
Labels: rootLabels,
CloudToken: cloudToken,
}),
doneCh: make(chan struct{}, 1),
}
clientConn := caller.Conn()
progClient := progrock.NewProgressServiceClient(clientConn)
progUpdates, err := progClient.WriteUpdates(ctx)
if err != nil {
return nil, err
}
progWriter, progCleanup, err := buildkit.ProgrockForwarder(bkClient.ProgSockPath, progrock.MultiWriter{
progrock.NewRPCWriter(clientConn, progUpdates),
buildkit.ProgrockLogrusWriter{},
})
if err != nil {
return nil, err
}
srv.progCleanup = progCleanup
progrockLabels := []*progrock.Label{}
for _, label := range rootLabels {
progrockLabels = append(progrockLabels, &progrock.Label{
Name: label.Name,
Value: label.Value,
})
}
srv.recorder = progrock.NewRecorder(progWriter, progrock.WithLabels(progrockLabels...))
// NOTE: context.Background is used because if the provided context is canceled, buildkit can
// leave internal progress contexts open and leak goroutines.
bkClient.WriteStatusesTo(context.Background(), srv.recorder)
apiSchema, err := schema.New(ctx, schema.InitializeArgs{
BuildkitClient: srv.bkClient,
Platform: srv.worker.Platforms(true)[0],
ProgSockPath: bkClient.ProgSockPath,
OCIStore: srv.worker.ContentStore(),
LeaseManager: srv.worker.LeaseManager(),
Secrets: secretStore,
Auth: authProvider,
})
if err != nil {
return nil, err
}
srv.schema = apiSchema
return srv, nil
}
func (srv *DaggerServer) LogMetrics(l *logrus.Entry) *logrus.Entry {
srv.clientMu.RLock()
defer srv.clientMu.RUnlock()
return l.WithField(fmt.Sprintf("server-%s-client-count", srv.serverID), srv.connectedClients)
}
func (srv *DaggerServer) Close() {
defer srv.closeOnce.Do(func() {
close(srv.doneCh)
})
// mark all groups completed
srv.recorder.Complete()
// close the recorder so the UI exits
srv.recorder.Close()
srv.progCleanup()
// close the analytics recorder
srv.analytics.Close()
}
func (srv *DaggerServer) Wait(ctx context.Context) error {
select {
case <-ctx.Done():
return ctx.Err()
case <-srv.doneCh:
return nil
}
}
func (srv *DaggerServer) ServeClientConn(
ctx context.Context,
clientMetadata *engine.ClientMetadata,
conn net.Conn,
) error {
bklog.G(ctx).Trace("serve client conn")
defer bklog.G(ctx).Trace("done serving client conn")
srv.clientMu.Lock()
srv.connectedClients++
defer func() {
srv.clientMu.Lock()
srv.connectedClients--
srv.clientMu.Unlock()
}()
srv.clientMu.Unlock()
conn = newLogicalDeadlineConn(nopCloserConn{conn})
l := &singleConnListener{conn: conn, closeCh: make(chan struct{})}
go func() {
<-ctx.Done()
l.Close()
}()
// NOTE: not sure how inefficient making a new server per-request is, fix if it's meaningful.
// Maybe we could dynamically mux in more endpoints for each client or something
handler, handlerDone, err := srv.HTTPHandlerForClient(clientMetadata, conn, bklog.G(ctx))
if err != nil {
return fmt.Errorf("failed to create http handler: %w", err)
}
defer func() {
<-handlerDone
bklog.G(ctx).Trace("handler done")
}()
httpSrv := http.Server{
Handler: handler,
ReadHeaderTimeout: 30 * time.Second,
}
defer httpSrv.Close()
return httpSrv.Serve(l)
}
func (srv *DaggerServer) HTTPHandlerForClient(clientMetadata *engine.ClientMetadata, conn net.Conn, lg *logrus.Entry) (http.Handler, <-chan struct{}, error) {
doneCh := make(chan struct{})
return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
defer close(doneCh)
req = req.WithContext(bklog.WithLogger(req.Context(), lg))
bklog.G(req.Context()).Debugf("http handler for client conn to path %s", req.URL.Path)
defer bklog.G(req.Context()).Debugf("http handler for client conn done: %s", clientMetadata.ClientID)
req = req.WithContext(progrock.ToContext(req.Context(), srv.recorder))
req = req.WithContext(engine.ContextWithClientMetadata(req.Context(), clientMetadata))
req = req.WithContext(analytics.WithContext(req.Context(), srv.analytics))
srv.schema.ServeHTTP(w, req)
}), doneCh, nil
}
// converts a pre-existing net.Conn into a net.Listener that returns the conn and then blocks
type singleConnListener struct {
conn net.Conn
l sync.Mutex
closeCh chan struct{}
closeOnce sync.Once
}
func (l *singleConnListener) Accept() (net.Conn, error) {
l.l.Lock()
if l.conn == nil {
l.l.Unlock()
<-l.closeCh
return nil, io.ErrClosedPipe
}
defer l.l.Unlock()
c := l.conn
l.conn = nil
return c, nil
}
func (l *singleConnListener) Addr() net.Addr {
return nil
}
func (l *singleConnListener) Close() error {
l.closeOnce.Do(func() {
close(l.closeCh)
})
return nil
}
type nopCloserConn struct {
net.Conn
}
func (nopCloserConn) Close() error {
return nil
}
// TODO: could also implement this upstream on:
// https://github.com/sipsma/buildkit/blob/fa11bf9e57a68e3b5252386fdf44042dd672949a/session/grpchijack/dial.go#L45-L45
type withDeadlineConn struct {
conn net.Conn
readDeadline time.Time
readers []func()
readBuf *bytes.Buffer
readEOF bool
readCond *sync.Cond
writeDeadline time.Time
writers []func()
writersL sync.Mutex
}
func newLogicalDeadlineConn(inner net.Conn) net.Conn {
c := &withDeadlineConn{
conn: inner,
readBuf: new(bytes.Buffer),
readCond: sync.NewCond(new(sync.Mutex)),
}
go func() {
for {
buf := make([]byte, 32*1024)
n, err := inner.Read(buf)
if err != nil {
c.readCond.L.Lock()
c.readEOF = true
c.readCond.L.Unlock()
c.readCond.Broadcast()
return
}
c.readCond.L.Lock()
c.readBuf.Write(buf[0:n])
c.readCond.Broadcast()
c.readCond.L.Unlock()
}
}()
return c
}
func (c *withDeadlineConn) Read(b []byte) (n int, err error) {
c.readCond.L.Lock()
if c.readEOF {
c.readCond.L.Unlock()
return 0, io.EOF
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
if !c.readDeadline.IsZero() {
if time.Now().After(c.readDeadline) {
c.readCond.L.Unlock()
// return early without calling inner Read
return 0, os.ErrDeadlineExceeded
}
go func() {
dt := time.Until(c.readDeadline)
if dt > 0 {
time.Sleep(dt)
}
cancel()
}()
}
// Keep track of the reader so a future SetReadDeadline can interrupt it.
c.readers = append(c.readers, cancel)
c.readCond.L.Unlock()
// Start a goroutine for the actual Read operation
read := make(chan struct{})
var rN int
var rerr error
go func() {
defer close(read)
c.readCond.L.Lock()
defer c.readCond.L.Unlock()
for ctx.Err() == nil {
if c.readEOF {
rerr = io.EOF
break
}
n, _ := c.readBuf.Read(b) // ignore EOF here
if n > 0 {
rN = n
break
}
c.readCond.Wait()
}
}()
// Wait for either Read to complete or the timeout
select {
case <-read:
return rN, rerr
case <-ctx.Done():
return 0, os.ErrDeadlineExceeded
}
}
func (c *withDeadlineConn) Write(b []byte) (n int, err error) {
c.writersL.Lock()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
if !c.writeDeadline.IsZero() {
if time.Now().After(c.writeDeadline) {
c.writersL.Unlock()
// return early without calling inner Write
return 0, os.ErrDeadlineExceeded
}
go func() {
dt := time.Until(c.writeDeadline)
if dt > 0 {
time.Sleep(dt)
}
cancel()
}()
}
// Keep track of the writer so a future SetWriteDeadline can interrupt it.
c.writers = append(c.writers, cancel)
c.writersL.Unlock()
// Start a goroutine for the actual Write operation
write := make(chan int, 1)
go func() {
n, err = c.conn.Write(b)
write <- 0
}()
// Wait for either Write to complete or the timeout
select {
case <-write:
return n, err
case <-ctx.Done():
return 0, os.ErrDeadlineExceeded
}
}
func (c *withDeadlineConn) Close() error {
return c.conn.Close()
}
func (c *withDeadlineConn) LocalAddr() net.Addr {
return c.conn.LocalAddr()
}
func (c *withDeadlineConn) RemoteAddr() net.Addr {
return c.conn.RemoteAddr()
}
func (c *withDeadlineConn) SetDeadline(t time.Time) error {
return errors.Join(
c.SetReadDeadline(t),
c.SetWriteDeadline(t),
)
}
func (c *withDeadlineConn) SetReadDeadline(t time.Time) error {
c.readCond.L.Lock()
c.readDeadline = t
readers := c.readers
c.readCond.L.Unlock()
if len(readers) > 0 && !t.IsZero() {
go func() {
dt := time.Until(c.readDeadline)
if dt > 0 {
time.Sleep(dt)
}
for _, cancel := range readers {
cancel()
}
}()
}
return nil
}
func (c *withDeadlineConn) SetWriteDeadline(t time.Time) error {
c.writersL.Lock()
c.writeDeadline = t
writers := c.writers
c.writersL.Unlock()
if len(writers) > 0 && !t.IsZero() {
go func() {
dt := time.Until(c.writeDeadline)
if dt > 0 {
time.Sleep(dt)
}
for _, cancel := range writers {
cancel()
}
}()
}
return nil
}
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,725 | Support passing modules as arguments in the CLI | Modules can accept other modules as arguments to functions. Use cases:
1. SDKs implemented as modules do this already by accepting `ModuleSource` as an arg
2. Support for running tests of modules could use this: https://github.com/dagger/dagger/issues/6724
3. Support for re-executing modules in specialized hosts (i.e. run my module on a "gpu-as-a-service" platform)
4. Combined with support for interfaces, you could pass a module as an implementation of an interface argument (if it matches)
* @vito mentioned one use case specifically around using this to construct a dev env that is defined across multiple modules and could be dynamically composed into one (IIUC, correct if I misunderstood)
However, it's not yet possible to do this from the CLI with `dagger call`, which greatly limits its utility. We could likely just re-use the syntax we use for `-m`, e.g.:
* `dagger call go-test --module github.com/my-org/my-repo/my-mod`, where `--module` is an argument of type either `ModuleSource`, `Module` or an interface that the module must implement.
That would in theory be extremely straightforward to implement while also unlocking all sorts of very interesting use cases | https://github.com/dagger/dagger/issues/6725 | https://github.com/dagger/dagger/pull/6761 | c5bf6978ba169abbc5cef54b3d7cd829f141d792 | e02ff3d2b50665275deb52902abc46ac0f6f138a | "2024-02-23T18:56:08Z" | go | "2024-02-27T22:55:04Z" | cmd/dagger/flags.go | package main
import (
"bytes"
"context"
"crypto/sha256"
"encoding/csv"
"encoding/hex"
"fmt"
"io"
"net"
"net/url"
"os"
"os/exec"
"path/filepath"
"reflect"
"strconv"
"strings"
"dagger.io/dagger"
"github.com/moby/buildkit/util/gitutil"
"github.com/spf13/pflag"
)
// GetCustomFlagValue returns a pflag.Value instance for a dagger.ObjectTypeDef name.
func GetCustomFlagValue(name string) DaggerValue {
switch name {
case Container:
return &containerValue{}
case Directory:
return &directoryValue{}
case File:
return &fileValue{}
case Secret:
return &secretValue{}
case Service:
return &serviceValue{}
case PortForward:
return &portForwardValue{}
case CacheVolume:
return &cacheVolumeValue{}
}
return nil
}
// GetCustomFlagValueSlice returns a pflag.Value instance for a dagger.ObjectTypeDef name.
func GetCustomFlagValueSlice(name string) DaggerValue {
switch name {
case Container:
return &sliceValue[*containerValue]{}
case Directory:
return &sliceValue[*directoryValue]{}
case File:
return &sliceValue[*fileValue]{}
case Secret:
return &sliceValue[*secretValue]{}
case Service:
return &sliceValue[*serviceValue]{}
case PortForward:
return &sliceValue[*portForwardValue]{}
case CacheVolume:
return &sliceValue[*cacheVolumeValue]{}
}
return nil
}
// DaggerValue is a pflag.Value that requires a dagger.Client for producing the
// final value.
type DaggerValue interface {
pflag.Value
// Get returns the final value for the query builder.
Get(context.Context, *dagger.Client) (any, error)
}
// sliceValue is a pflag.Value that builds a slice of DaggerValue instances.
//
// NOTE: the code defining this type is heavily inspired by stringSliceValue.Set
// for equivalent behaviour as the other builtin slice types
type sliceValue[T DaggerValue] struct {
value []T
}
func (v *sliceValue[T]) Type() string {
var t T
return t.Type()
}
func (v *sliceValue[T]) String() string {
ss := []string{}
for _, v := range v.value {
ss = append(ss, v.String())
}
out, _ := writeAsCSV(ss)
return "[" + out + "]"
}
func (v *sliceValue[T]) Get(ctx context.Context, c *dagger.Client) (any, error) {
out := make([]any, len(v.value))
for i, v := range v.value {
outV, err := v.Get(ctx, c)
if err != nil {
return nil, err
}
out[i] = outV
}
return out, nil
}
func (v *sliceValue[T]) Set(s string) error {
// remove all quote characters
rmQuote := strings.NewReplacer(`"`, "", `'`, "", "`", "")
// read flag arguments with CSV parser
ss, err := readAsCSV(rmQuote.Replace(s))
if err != nil && err != io.EOF {
return err
}
// parse values into slice
out := make([]T, 0, len(ss))
for _, s := range ss {
var v T
if typ := reflect.TypeOf(v); typ.Kind() == reflect.Ptr {
// hack to get a pointer to a new instance of the underlying type
v = reflect.New(typ.Elem()).Interface().(T)
}
if err := v.Set(strings.TrimSpace(s)); err != nil {
return err
}
out = append(out, v)
}
v.value = append(v.value, out...)
return nil
}
// containerValue is a pflag.Value that builds a dagger.Container from a
// base image name.
type containerValue struct {
address string
}
func (v *containerValue) Type() string {
return Container
}
func (v *containerValue) Set(s string) error {
if s == "" {
return fmt.Errorf("container address cannot be empty")
}
v.address = s
return nil
}
func (v *containerValue) String() string {
return v.address
}
func (v *containerValue) Get(_ context.Context, c *dagger.Client) (any, error) {
if v.address == "" {
return nil, fmt.Errorf("container address cannot be empty")
}
return c.Container().From(v.String()), nil
}
// directoryValue is a pflag.Value that builds a dagger.Directory from a host path.
type directoryValue struct {
address string
}
func (v *directoryValue) Type() string {
return Directory
}
func (v *directoryValue) Set(s string) error {
if s == "" {
return fmt.Errorf("directory address cannot be empty")
}
v.address = s
return nil
}
func (v *directoryValue) String() string {
return v.address
}
func (v *directoryValue) Get(_ context.Context, dag *dagger.Client) (any, error) {
if v.String() == "" {
return nil, fmt.Errorf("directory address cannot be empty")
}
// Try parsing as a Git URL
parsedGit, err := parseGit(v.String())
if err == nil {
gitOpts := dagger.GitOpts{
KeepGitDir: true,
}
if authSock, ok := os.LookupEnv("SSH_AUTH_SOCK"); ok {
gitOpts.SSHAuthSocket = dag.Host().UnixSocket(authSock)
}
gitDir := dag.Git(parsedGit.Remote, gitOpts).Branch(parsedGit.Fragment.Ref).Tree()
if subdir := parsedGit.Fragment.Subdir; subdir != "" {
gitDir = gitDir.Directory(subdir)
}
return gitDir, nil
}
// Otherwise it's a local dir path. Allow `file://` scheme or no scheme.
vStr := v.String()
vStr = strings.TrimPrefix(vStr, "file://")
if !filepath.IsAbs(vStr) {
vStr, err = filepath.Abs(vStr)
if err != nil {
return nil, fmt.Errorf("failed to resolve absolute path: %w", err)
}
}
return dag.Host().Directory(vStr), nil
}
func parseGit(urlStr string) (*gitutil.GitURL, error) {
// FIXME: handle tarball-over-http (where http(s):// is scheme but not a git repo)
u, err := gitutil.ParseURL(urlStr)
if err != nil {
return nil, err
}
if u.Fragment == nil {
u.Fragment = &gitutil.GitURLFragment{}
}
if u.Fragment.Ref == "" {
// FIXME: default branch can be remotely looked up, but that would
// require 1) a context, 2) a way to return an error, 3) more time than I have :)
u.Fragment.Ref = "main"
}
return u, nil
}
// fileValue is a pflag.Value that builds a dagger.File from a host path.
type fileValue struct {
path string
}
func (v *fileValue) Type() string {
return File
}
func (v *fileValue) Set(s string) error {
if s == "" {
return fmt.Errorf("file path cannot be empty")
}
v.path = s
return nil
}
func (v *fileValue) String() string {
return v.path
}
func (v *fileValue) Get(_ context.Context, c *dagger.Client) (any, error) {
vStr := v.String()
if vStr == "" {
return nil, fmt.Errorf("file path cannot be empty")
}
vStr = strings.TrimPrefix(vStr, "file://")
if !filepath.IsAbs(vStr) {
var err error
vStr, err = filepath.Abs(vStr)
if err != nil {
return nil, fmt.Errorf("failed to resolve absolute path: %w", err)
}
}
return c.Host().File(vStr), nil
}
// secretValue is a pflag.Value that builds a dagger.Secret from a name and a
// plaintext value.
type secretValue struct {
secretSource string
sourceVal string
}
const (
envSecretSource = "env"
fileSecretSource = "file"
commandSecretSource = "cmd"
)
func (v *secretValue) Type() string {
return Secret
}
func (v *secretValue) Set(s string) error {
secretSource, val, ok := strings.Cut(s, ":")
if !ok {
// case of e.g. `--token MY_ENV_SECRET`, which is shorthand for `--token env:MY_ENV_SECRET`
val = secretSource
secretSource = envSecretSource
}
v.secretSource = secretSource
v.sourceVal = val
return nil
}
func (v *secretValue) String() string {
return fmt.Sprintf("%s:%s", v.secretSource, v.sourceVal)
}
func (v *secretValue) Get(ctx context.Context, c *dagger.Client) (any, error) {
var plaintext string
switch v.secretSource {
case envSecretSource:
envPlaintext, ok := os.LookupEnv(v.sourceVal)
if !ok {
// Don't show the entire env var name, in case the user accidentally passed the value instead...
// This is important because users originally *did* have to pass the value, before we changed to
// passing by name instead.
key := v.sourceVal
if len(key) >= 4 {
key = key[:3] + "..."
}
return nil, fmt.Errorf("secret env var not found: %q", key)
}
plaintext = envPlaintext
case fileSecretSource:
filePlaintext, err := os.ReadFile(v.sourceVal)
if err != nil {
return nil, fmt.Errorf("failed to read secret file %q: %w", v.sourceVal, err)
}
plaintext = string(filePlaintext)
case commandSecretSource:
// #nosec G204
stdoutBytes, err := exec.CommandContext(ctx, "sh", "-c", v.sourceVal).Output()
if err != nil {
return nil, fmt.Errorf("failed to run secret command %q: %w", v.sourceVal, err)
}
plaintext = string(stdoutBytes)
default:
return nil, fmt.Errorf("unsupported secret arg source: %q", v.secretSource)
}
// NB: If we allow getting the name from the dagger.Secret instance,
// it can be vulnerable to brute force attacks.
hash := sha256.Sum256([]byte(plaintext))
secretName := hex.EncodeToString(hash[:])
return c.SetSecret(secretName, plaintext), nil
}
// serviceValue is a pflag.Value that builds a dagger.Service from a host:port
// combination.
type serviceValue struct {
address string // for string representation
host string
ports []dagger.PortForward
}
func (v *serviceValue) Type() string {
return Service
}
func (v *serviceValue) String() string {
return v.address
}
func (v *serviceValue) Set(s string) error {
if s == "" {
return fmt.Errorf("service address cannot be empty")
}
u, err := url.Parse(s)
if err != nil {
return err
}
switch u.Scheme {
case "tcp":
host, port, err := net.SplitHostPort(u.Host)
if err != nil {
return err
}
nPort, err := strconv.Atoi(port)
if err != nil {
return err
}
v.host = host
v.ports = append(v.ports, dagger.PortForward{
Backend: nPort,
Frontend: nPort,
Protocol: dagger.Tcp,
})
case "udp":
host, port, err := net.SplitHostPort(u.Host)
if err != nil {
return err
}
nPort, err := strconv.Atoi(port)
if err != nil {
return err
}
v.host = host
v.ports = append(v.ports, dagger.PortForward{
Backend: nPort,
Frontend: nPort,
Protocol: dagger.Udp,
})
default:
return fmt.Errorf("unsupported service address. Must be a valid tcp:// or udp:// URL")
}
v.address = s
return nil
}
func (v *serviceValue) Get(ctx context.Context, c *dagger.Client) (any, error) {
svc, err := c.Host().Service(v.ports, dagger.HostServiceOpts{Host: v.host}).Start(ctx)
if err != nil {
return nil, fmt.Errorf("failed to start service: %w", err)
}
return svc, nil
}
// portForwardValue is a pflag.Value that builds a dagger.
type portForwardValue struct {
frontend int
backend int
}
func (v *portForwardValue) Type() string {
return PortForward
}
func (v *portForwardValue) Set(s string) error {
if s == "" {
return fmt.Errorf("portForward setting cannot be empty")
}
frontendStr, backendStr, ok := strings.Cut(s, ":")
if !ok {
return fmt.Errorf("portForward setting not in the form of frontend:backend: %q", s)
}
frontend, err := strconv.Atoi(frontendStr)
if err != nil {
return fmt.Errorf("portForward frontend not a valid integer: %q", frontendStr)
}
v.frontend = frontend
backend, err := strconv.Atoi(backendStr)
if err != nil {
return fmt.Errorf("portForward backend not a valid integer: %q", backendStr)
}
v.backend = backend
return nil
}
func (v *portForwardValue) String() string {
return fmt.Sprintf("%d:%d", v.frontend, v.backend)
}
func (v *portForwardValue) Get(_ context.Context, c *dagger.Client) (any, error) {
return &dagger.PortForward{
Frontend: v.frontend,
Backend: v.backend,
}, nil
}
// cacheVolumeValue is a pflag.Value that builds a dagger.CacheVolume from a
// volume name.
type cacheVolumeValue struct {
name string
}
func (v *cacheVolumeValue) Type() string {
return CacheVolume
}
func (v *cacheVolumeValue) Set(s string) error {
if s == "" {
return fmt.Errorf("cacheVolume name cannot be empty")
}
v.name = s
return nil
}
func (v *cacheVolumeValue) String() string {
return v.name
}
func (v *cacheVolumeValue) Get(_ context.Context, dag *dagger.Client) (any, error) {
if v.String() == "" {
return nil, fmt.Errorf("cacheVolume name cannot be empty")
}
return dag.CacheVolume(v.name), nil
}
// AddFlag adds a flag appropriate for the argument type. Should return a
// pointer to the value.
func (r *modFunctionArg) AddFlag(flags *pflag.FlagSet, dag *dagger.Client) (any, error) {
name := r.FlagName()
usage := r.Description
if flags.Lookup(name) != nil {
return nil, fmt.Errorf("flag already exists: %s", name)
}
switch r.TypeDef.Kind {
case dagger.StringKind:
val, _ := getDefaultValue[string](r)
return flags.String(name, val, usage), nil
case dagger.IntegerKind:
val, _ := getDefaultValue[int](r)
return flags.Int(name, val, usage), nil
case dagger.BooleanKind:
val, _ := getDefaultValue[bool](r)
return flags.Bool(name, val, usage), nil
case dagger.ObjectKind:
objName := r.TypeDef.AsObject.Name
if val := GetCustomFlagValue(objName); val != nil {
flags.Var(val, name, usage)
return val, nil
}
// TODO: default to JSON?
return nil, fmt.Errorf("unsupported object type %q for flag: %s", objName, name)
case dagger.InputKind:
inputName := r.TypeDef.AsInput.Name
if val := GetCustomFlagValue(inputName); val != nil {
flags.Var(val, name, usage)
return val, nil
}
// TODO: default to JSON?
return nil, fmt.Errorf("unsupported input type %q for flag: %s", inputName, name)
case dagger.ListKind:
elementType := r.TypeDef.AsList.ElementTypeDef
switch elementType.Kind {
case dagger.StringKind:
val, _ := getDefaultValue[[]string](r)
return flags.StringSlice(name, val, usage), nil
case dagger.IntegerKind:
val, _ := getDefaultValue[[]int](r)
return flags.IntSlice(name, val, usage), nil
case dagger.BooleanKind:
val, _ := getDefaultValue[[]bool](r)
return flags.BoolSlice(name, val, usage), nil
case dagger.ObjectKind:
objName := elementType.AsObject.Name
if val := GetCustomFlagValueSlice(objName); val != nil {
flags.Var(val, name, usage)
return val, nil
}
// TODO: default to JSON?
return nil, fmt.Errorf("unsupported list of objects %q for flag: %s", objName, name)
case dagger.InputKind:
inputName := elementType.AsInput.Name
if val := GetCustomFlagValueSlice(inputName); val != nil {
flags.Var(val, name, usage)
return val, nil
}
// TODO: default to JSON?
return nil, fmt.Errorf("unsupported list of input type %q for flag: %s", inputName, name)
case dagger.ListKind:
return nil, fmt.Errorf("unsupported list of lists for flag: %s", name)
}
}
return nil, fmt.Errorf("unsupported type for argument: %s", r.Name)
}
func readAsCSV(val string) ([]string, error) {
if val == "" {
return []string{}, nil
}
stringReader := strings.NewReader(val)
csvReader := csv.NewReader(stringReader)
return csvReader.Read()
}
func writeAsCSV(vals []string) (string, error) {
b := &bytes.Buffer{}
w := csv.NewWriter(b)
err := w.Write(vals)
if err != nil {
return "", err
}
w.Flush()
return strings.TrimSuffix(b.String(), "\n"), nil
}
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,725 | Support passing modules as arguments in the CLI | Modules can accept other modules as arguments to functions. Use cases:
1. SDKs implemented as modules do this already by accepting `ModuleSource` as an arg
2. Support for running tests of modules could use this: https://github.com/dagger/dagger/issues/6724
3. Support for re-executing modules in specialized hosts (i.e. run my module on a "gpu-as-a-service" platform)
4. Combined with support for interfaces, you could pass a module as an implementation of an interface argument (if it matches)
* @vito mentioned one use case specifically around using this to construct a dev env that is defined across multiple modules and could be dynamically composed into one (IIUC, correct if I misunderstood)
However, it's not yet possible to do this from the CLI with `dagger call`, which greatly limits its utility. We could likely just re-use the syntax we use for `-m`, e.g.:
* `dagger call go-test --module github.com/my-org/my-repo/my-mod`, where `--module` is an argument of type either `ModuleSource`, `Module` or an interface that the module must implement.
That would in theory be extremely straightforward to implement while also unlocking all sorts of very interesting use cases | https://github.com/dagger/dagger/issues/6725 | https://github.com/dagger/dagger/pull/6761 | c5bf6978ba169abbc5cef54b3d7cd829f141d792 | e02ff3d2b50665275deb52902abc46ac0f6f138a | "2024-02-23T18:56:08Z" | go | "2024-02-27T22:55:04Z" | cmd/dagger/functions.go | package main
import (
"context"
"errors"
"fmt"
"sort"
"strings"
"dagger.io/dagger"
"dagger.io/dagger/querybuilder"
"github.com/dagger/dagger/dagql/idtui"
"github.com/dagger/dagger/engine/client"
"github.com/juju/ansiterm/tabwriter"
"github.com/muesli/termenv"
"github.com/spf13/cobra"
"github.com/spf13/pflag"
"github.com/vito/progrock"
)
const (
Directory string = "Directory"
Container string = "Container"
File string = "File"
Secret string = "Secret"
Service string = "Service"
Terminal string = "Terminal"
PortForward string = "PortForward"
CacheVolume string = "CacheVolume"
)
var funcGroup = &cobra.Group{
ID: "functions",
Title: "Function Commands",
}
var funcCmds = FuncCommands{
funcListCmd,
callCmd,
}
var funcListCmd = &FuncCommand{
Name: "functions [flags] [FUNCTION]...",
Short: `List available functions`,
Long: strings.ReplaceAll(`List available functions in a module.
This is similar to ´dagger call --help´, but only focused on showing the
available functions.
`,
"´",
"`",
),
Execute: func(fc *FuncCommand, cmd *cobra.Command) error {
tw := tabwriter.NewWriter(cmd.OutOrStdout(), 0, 0, 3, ' ', tabwriter.DiscardEmptyColumns)
var o functionProvider = fc.mod.GetMainObject()
fmt.Fprintf(tw, "%s\t%s\n",
termenv.String("Name").Bold(),
termenv.String("Description").Bold(),
)
// Walk the hypothetical function pipeline specified by the args
for _, field := range cmd.Flags().Args() {
// Lookup the next function in the specified pipeline
nextFunc, err := o.GetFunction(field)
if err != nil {
return err
}
nextType := nextFunc.ReturnType
if nextType.AsFunctionProvider() != nil {
// sipsma explains why 'nextType.AsObject' is not enough:
// > when we're returning the hierarchies of TypeDefs from the API,
// > and an object shows up as an output/input type to a function,
// > we just return a TypeDef with a name of the object rather than the full object definition.
// > You can get the full object definition only from the "top-level" returned object on the api call.
//
// > The reason is that if we repeated the full object definition every time,
// > you'd at best be using O(n^2) space in the result,
// > and at worst cause json serialization errors due to cyclic references
// > (i.e. with* functions on an object that return the object itself).
o = fc.mod.GetFunctionProvider(nextType.Name())
continue
}
// FIXME: handle arrays of objects
return fmt.Errorf("function %q returns type %q with no further functions available", field, nextType.Kind)
}
// List functions on the final object
fns := o.GetFunctions()
sort.Slice(fns, func(i, j int) bool {
return fns[i].Name < fns[j].Name
})
for _, fn := range fns {
desc := strings.SplitN(fn.Description, "\n", 2)[0]
if desc == "" {
desc = "-"
}
fmt.Fprintf(tw, "%s\t%s\n",
cliName(fn.Name),
desc,
)
}
return tw.Flush()
},
}
type FuncCommands []*FuncCommand
func (fcs FuncCommands) AddFlagSet(flags *pflag.FlagSet) {
for _, cmd := range fcs.All() {
cmd.PersistentFlags().AddFlagSet(flags)
}
}
func (fcs FuncCommands) AddParent(rootCmd *cobra.Command) {
rootCmd.AddCommand(fcs.All()...)
}
func (fcs FuncCommands) All() []*cobra.Command {
cmds := make([]*cobra.Command, len(fcs))
for i, fc := range fcs {
cmds[i] = fc.Command()
}
return cmds
}
func setCmdOutput(cmd *cobra.Command, vtx *progrock.VertexRecorder) {
cmd.SetOut(vtx.Stdout())
cmd.SetErr(vtx.Stderr())
}
// FuncCommand is a config object used to create a dynamic set of commands
// for querying a module's functions.
type FuncCommand struct {
// The name of the command (or verb), as shown in usage.
Name string
// Aliases is an array of aliases that can be used instead of the first word in Use.
Aliases []string
// Short is the short description shown in the 'help' output.
Short string
// Long is the long message shown in the 'help <this-command>' output.
Long string
// Example is examples of how to use the command.
Example string
// Init is called when the command is created and initialized,
// before execution.
//
// It can be useful to add persistent flags for all subcommands here.
Init func(*cobra.Command)
// Execute circumvents the default behavior of traversing subcommands
// from the arguments, but still has access to the loaded objects from
// the module.
Execute func(*FuncCommand, *cobra.Command) error
// BeforeParse is called before parsing the flags for a subcommand.
//
// It can be useful to add any additional flags for a subcommand here.
BeforeParse func(*FuncCommand, *cobra.Command, *modFunction) error
// OnSelectObjectLeaf is called when a user provided command ends in a
// object and no more sub-commands are provided.
//
// If set, it should make another selection on the object that results
// return no error. Otherwise if it doesn't handle the object, it should
// return an error.
OnSelectObjectLeaf func(*FuncCommand, string) error
// BeforeRequest is called before making the request with the query that
// contains the whole chain of functions.
//
// It can be useful to validate the return type of the function or as a
// last effort to select a GraphQL sub-field.
BeforeRequest func(*FuncCommand, *cobra.Command, *modTypeDef) error
// AfterResponse is called when the query has completed and returned a result.
AfterResponse func(*FuncCommand, *cobra.Command, *modTypeDef, any) error
// cmd is the parent cobra command.
cmd *cobra.Command
// mod is the loaded module definition.
mod *moduleDef
// showHelp is set in the loader vertex to flag whether to show the help
// in the execution vertex.
showHelp bool
// showUsage flags whether to show a one-line usage message after error.
showUsage bool
q *querybuilder.Selection
c *client.Client
}
func (fc *FuncCommand) Command() *cobra.Command {
if fc.cmd == nil {
fc.cmd = &cobra.Command{
Use: fc.Name,
Aliases: fc.Aliases,
Short: fc.Short,
Long: fc.Long,
Example: fc.Example,
GroupID: moduleGroup.ID,
// We need to disable flag parsing because it'll act on --help
// and validate the args before we have a chance to add the
// subcommands.
DisableFlagParsing: true,
DisableFlagsInUseLine: true,
PreRunE: func(c *cobra.Command, a []string) error {
// Recover what DisableFlagParsing disabled.
// In PreRunE it's, already past the --help check and
// args validation, but not flag validation which we want.
c.DisableFlagParsing = false
// Since we disabled flag parsing, we'll get all args,
// not just flags. We want to stop parsing at the first
// possible dynamic sub-command since they've not been
// added yet.
c.Flags().SetInterspersed(false)
// Allow using flags with the name that was reported
// by the SDK. This avoids confusion as users are editing
// a module and trying to test its functions.
c.SetGlobalNormalizationFunc(func(f *pflag.FlagSet, name string) pflag.NormalizedName {
return pflag.NormalizedName(cliName(name))
})
// temporarily allow unknown flags so we can parse any global flags before starting
// the engine+TUI while not erroring out on module constructor flags (which can't be
// added until the engine has started)
c.FParseErrWhitelist.UnknownFlags = true
if err := c.ParseFlags(a); err != nil {
// This gives a chance for FuncCommand implementations to
// handle errors from parsing flags.
return c.FlagErrorFunc()(c, err)
}
c.FParseErrWhitelist.UnknownFlags = false
fc.showHelp, _ = c.Flags().GetBool("help")
return nil
},
// Between PreRunE and RunE, flags are validated.
RunE: func(c *cobra.Command, a []string) error {
return withEngineAndTUI(c.Context(), client.Params{}, func(ctx context.Context, engineClient *client.Client) (rerr error) {
fc.c = engineClient
// withEngineAndTUI changes the context.
c.SetContext(ctx)
// We need to print the errors ourselves because the root command
// will print the command path for this one (parent), not any
// sub-command.
c.SilenceErrors = true
return fc.execute(c, a)
})
},
}
if fc.Init != nil {
fc.Init(fc.cmd)
}
}
return fc.cmd
}
func (fc *FuncCommand) execute(c *cobra.Command, a []string) (rerr error) {
ctx := c.Context()
var primaryVtx *progrock.VertexRecorder
var cmd *cobra.Command
// The following is a little complicated because it needs to handle the case
// where we fail to load the modules or parse the CLI.
//
// In the happy path we want to initialize the PrimaryVertex with the parsed
// command string, but we can't have that until we load the command.
//
// So we just detect if we failed before getting to that point and fall back
// to the outer command.
defer func() {
if cmd == nil { // errored during loading
cmd = c
}
if primaryVtx == nil { // errored during loading
ctx, primaryVtx = progrock.Span(ctx, idtui.PrimaryVertex, cmd.CommandPath())
defer func() { primaryVtx.Done(rerr) }()
cmd.SetContext(ctx)
setCmdOutput(cmd, primaryVtx)
}
if ctx.Err() != nil {
cmd.PrintErrln("Canceled.")
} else if rerr != nil {
cmd.PrintErrln("Error:", rerr.Error())
if fc.showHelp {
// Explicitly show the help here while still returning the error.
// This handles the case of `dagger call --help` run on a broken module; in that case
// we want to error out since we can't actually load the module and show all subcommands
// and flags in the help output, but we still want to show the user *something*
cmd.Help()
}
if fc.showUsage {
cmd.PrintErrf("Run '%v --help' for usage.\n", cmd.CommandPath())
}
}
}()
// Load the command, which may fail if modules are broken.
cmd, flags, err := fc.load(c, a)
if err != nil {
return err
}
// Ok, we've loaded the command, now we can initialize the PrimaryVertex.
ctx, primaryVtx = progrock.Span(ctx, idtui.PrimaryVertex, cmd.CommandPath())
defer func() { primaryVtx.Done(rerr) }()
cmd.SetContext(ctx)
setCmdOutput(cmd, primaryVtx)
if fc.showHelp {
// Hide aliases for sub-commands. They just allow using the SDK's
// casing for functions but there's no need to advertise.
if cmd != c {
cmd.Aliases = nil
}
return cmd.Help()
}
// There should be no args left, if there are it's an unknown command.
if err := cobra.NoArgs(cmd, flags); err != nil {
return err
}
if fc.Execute != nil {
return fc.Execute(fc, cmd)
}
// No args to the parent command, default to showing help.
if cmd == c {
return cmd.Help()
}
err = cmd.RunE(cmd, flags)
if err != nil {
return err
}
return nil
}
func (fc *FuncCommand) load(c *cobra.Command, a []string) (cmd *cobra.Command, _ []string, rerr error) {
ctx := c.Context()
dag := fc.c.Dagger()
ctx, vtx := progrock.Span(ctx, idtui.InitVertex, "initialize")
defer func() { vtx.Done(rerr) }()
modConf, err := getDefaultModuleConfiguration(ctx, dag, true)
if err != nil {
return nil, nil, fmt.Errorf("failed to get configured module: %w", err)
}
if !modConf.FullyInitialized() {
return nil, nil, fmt.Errorf("module at source dir %q doesn't exist or is invalid", modConf.LocalRootSourcePath)
}
mod := modConf.Source.AsModule().Initialize()
_, err = mod.Serve(ctx)
if err != nil {
return nil, nil, err
}
modDef, err := loadModTypeDefs(ctx, dag, mod)
if err != nil {
return nil, nil, err
}
obj := modDef.GetMainObject()
if obj == nil {
return nil, nil, fmt.Errorf("main object not found")
}
fc.mod = modDef
if fc.Execute != nil {
// if `Execute` is set, there's no need for sub-commands.
return c, nil, nil
}
if obj.Constructor != nil {
// add constructor args as top-level flags
if err := fc.addArgsForFunction(c, a, obj.Constructor, dag); err != nil {
return nil, nil, err
}
fc.selectFunc(obj.Name, obj.Constructor, c, dag)
} else {
fc.Select(obj.Name)
}
// Add main object's functions as subcommands
fc.addSubCommands(c, dag, obj)
if fc.showHelp {
return c, nil, nil
}
cmd, flags, err := fc.traverse(c)
if err != nil {
if errors.Is(err, pflag.ErrHelp) {
fc.showHelp = true
return cmd, flags, nil
}
fc.showUsage = true
return cmd, flags, err
}
return cmd, flags, nil
}
// traverse the arguments to build the command tree and return the leaf command.
func (fc *FuncCommand) traverse(c *cobra.Command) (*cobra.Command, []string, error) {
cmd, args, err := c.Find(c.Flags().Args())
if err != nil {
return cmd, args, err
}
// Leaf command
if cmd == c {
return cmd, args, nil
}
cmd.SetContext(c.Context())
cmd.InitDefaultHelpFlag()
// Load and ParseFlags
err = cmd.PreRunE(cmd, args)
if err != nil {
return cmd, args, err
}
return fc.traverse(cmd)
}
func (fc *FuncCommand) addSubCommands(cmd *cobra.Command, dag *dagger.Client, fnProvider functionProvider) {
if fnProvider != nil {
cmd.AddGroup(funcGroup)
for _, fn := range fnProvider.GetFunctions() {
subCmd := fc.makeSubCmd(dag, fn)
cmd.AddCommand(subCmd)
}
}
}
func (fc *FuncCommand) makeSubCmd(dag *dagger.Client, fn *modFunction) *cobra.Command {
newCmd := &cobra.Command{
Use: cliName(fn.Name),
Short: strings.SplitN(fn.Description, "\n", 2)[0],
Long: fn.Description,
GroupID: funcGroup.ID,
PreRunE: func(cmd *cobra.Command, args []string) (err error) {
if err := fc.addArgsForFunction(cmd, args, fn, dag); err != nil {
return err
}
fnProvider := fn.ReturnType.AsFunctionProvider()
if fnProvider == nil && fn.ReturnType.AsList != nil {
fnProvider = fn.ReturnType.AsList.ElementTypeDef.AsFunctionProvider()
}
fc.addSubCommands(cmd, dag, fnProvider)
// Show help for first command that has the --help flag.
help, _ := cmd.Flags().GetBool("help")
if help {
return pflag.ErrHelp
}
// Need to make the query selection before chaining off.
return fc.selectFunc(fn.Name, fn, cmd, dag)
},
// This is going to be executed in the "execution" vertex, when
// we have the final/leaf command.
RunE: func(cmd *cobra.Command, args []string) (err error) {
switch fn.ReturnType.Kind {
case dagger.ObjectKind, dagger.InterfaceKind:
if fc.OnSelectObjectLeaf == nil {
// there is no handling of this object and no further selections, error out
fc.showUsage = true
return fmt.Errorf("%q requires a sub-command", cmd.Name())
}
// the top-level command may handle this via OnSelectObjectLeaf
err := fc.OnSelectObjectLeaf(fc, fn.ReturnType.Name())
if err != nil {
fc.showUsage = true
return fmt.Errorf("invalid selection for command %q: %w", cmd.Name(), err)
}
case dagger.ListKind:
fnProvider := fn.ReturnType.AsList.ElementTypeDef.AsFunctionProvider()
if fnProvider != nil && len(fnProvider.GetFunctions()) > 0 {
// we don't handle lists of objects/interfaces w/ extra functions on any commands right now
fc.showUsage = true
return fmt.Errorf("%q requires a sub-command", cmd.Name())
}
}
if fc.BeforeRequest != nil {
if err = fc.BeforeRequest(fc, cmd, fn.ReturnType); err != nil {
return err
}
}
ctx := cmd.Context()
query, _ := fc.q.Build(ctx)
rec := progrock.FromContext(ctx)
rec.Debug("executing", progrock.Labelf("query", "%+v", query))
var response any
q := fc.q.Bind(&response)
if err := q.Execute(ctx, dag.Client); err != nil {
return fmt.Errorf("response from query: %w", err)
}
if fc.AfterResponse != nil {
return fc.AfterResponse(fc, cmd, fn.ReturnType, response)
}
if fn.ReturnType.Kind != dagger.VoidKind {
cmd.Println(response)
}
return nil
},
}
// Allow using the function name from the SDK as an alias for the command.
if fn.Name != newCmd.Name() {
newCmd.Aliases = append(newCmd.Aliases, fn.Name)
}
newCmd.Flags().SetInterspersed(false)
return newCmd
}
func (fc *FuncCommand) addArgsForFunction(cmd *cobra.Command, cmdArgs []string, fn *modFunction, dag *dagger.Client) error {
fc.mod.LoadTypeDef(fn.ReturnType)
for _, arg := range fn.Args {
fc.mod.LoadTypeDef(arg.TypeDef)
}
for _, arg := range fn.Args {
_, err := arg.AddFlag(cmd.Flags(), dag)
if err != nil {
return err
}
if !arg.TypeDef.Optional && arg.DefaultValue == "" {
cmd.MarkFlagRequired(arg.FlagName())
}
}
if fc.BeforeParse != nil {
if err := fc.BeforeParse(fc, cmd, fn); err != nil {
return err
}
}
if err := cmd.ParseFlags(cmdArgs); err != nil {
// This gives a chance for FuncCommand implementations to
// handle errors from parsing flags.
return cmd.FlagErrorFunc()(cmd, err)
}
help, _ := cmd.Flags().GetBool("help")
if !help {
if err := cmd.ValidateRequiredFlags(); err != nil {
return err
}
if err := cmd.ValidateFlagGroups(); err != nil {
return err
}
}
return nil
}
// selectFunc adds the function selection to the query.
// Note that the type can change if there's an extra selection for supported types.
func (fc *FuncCommand) selectFunc(selectName string, fn *modFunction, cmd *cobra.Command, dag *dagger.Client) error {
fc.Select(selectName)
for _, arg := range fn.Args {
var val any
flag := cmd.Flags().Lookup(arg.FlagName())
if flag == nil {
return fmt.Errorf("no flag for %q", arg.FlagName())
}
// Don't send optional arguments that weren't set.
if arg.TypeDef.Optional && !flag.Changed {
continue
}
val = flag.Value
switch v := val.(type) {
case DaggerValue:
obj, err := v.Get(cmd.Context(), dag)
if err != nil {
return fmt.Errorf("failed to get value for argument %q: %w", arg.Name, err)
}
if obj == nil {
return fmt.Errorf("no value for argument: %s", arg.Name)
}
val = obj
case pflag.SliceValue:
val = v.GetSlice()
}
fc.Arg(arg.Name, val)
}
return nil
}
func (fc *FuncCommand) Select(name string) {
if fc.q == nil {
fc.q = querybuilder.Query()
}
fc.q = fc.q.Select(gqlFieldName(name))
}
func (fc *FuncCommand) Arg(name string, value any) {
fc.q = fc.q.Arg(gqlArgName(name), value)
}
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,725 | Support passing modules as arguments in the CLI | Modules can accept other modules as arguments to functions. Use cases:
1. SDKs implemented as modules do this already by accepting `ModuleSource` as an arg
2. Support for running tests of modules could use this: https://github.com/dagger/dagger/issues/6724
3. Support for re-executing modules in specialized hosts (i.e. run my module on a "gpu-as-a-service" platform)
4. Combined with support for interfaces, you could pass a module as an implementation of an interface argument (if it matches)
* @vito mentioned one use case specifically around using this to construct a dev env that is defined across multiple modules and could be dynamically composed into one (IIUC, correct if I misunderstood)
However, it's not yet possible to do this from the CLI with `dagger call`, which greatly limits its utility. We could likely just re-use the syntax we use for `-m`, e.g.:
* `dagger call go-test --module github.com/my-org/my-repo/my-mod`, where `--module` is an argument of type either `ModuleSource`, `Module` or an interface that the module must implement.
That would in theory be extremely straightforward to implement while also unlocking all sorts of very interesting use cases | https://github.com/dagger/dagger/issues/6725 | https://github.com/dagger/dagger/pull/6761 | c5bf6978ba169abbc5cef54b3d7cd829f141d792 | e02ff3d2b50665275deb52902abc46ac0f6f138a | "2024-02-23T18:56:08Z" | go | "2024-02-27T22:55:04Z" | core/integration/module_call_test.go | package core
import (
"fmt"
"strings"
"testing"
"dagger.io/dagger"
"github.com/moby/buildkit/identity"
"github.com/stretchr/testify/require"
)
func TestModuleDaggerCallArgTypes(t *testing.T) {
t.Parallel()
t.Run("service args", func(t *testing.T) {
t.Parallel()
t.Run("used as service binding", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
)
type Test struct {}
func (m *Test) Fn(ctx context.Context, svc *Service) (string, error) {
return dag.Container().From("alpine:3.18").WithExec([]string{"apk", "add", "curl"}).
WithServiceBinding("daserver", svc).
WithExec([]string{"curl", "http://daserver:8000"}).
Stdout(ctx)
}
`,
})
logGen(ctx, t, modGen.Directory("."))
httpServer, _ := httpService(ctx, t, c, "im up")
endpoint, err := httpServer.Endpoint(ctx)
require.NoError(t, err)
out, err := modGen.
WithServiceBinding("testserver", httpServer).
With(daggerCall("fn", "--svc", "tcp://"+endpoint)).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "im up", out)
})
t.Run("used directly", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
"fmt"
"strings"
)
type Test struct {}
func (m *Test) Fn(ctx context.Context, svc *Service) (string, error) {
ports, err := svc.Ports(ctx)
if err != nil {
return "", err
}
var out []string
out = append(out, fmt.Sprintf("%d exposed ports:", len(ports)))
for _, port := range ports {
number, err := port.Port(ctx)
if err != nil {
return "", err
}
out = append(out, fmt.Sprintf("- TCP/%d", number))
}
return strings.Join(out, "\n"), nil
}
`,
})
logGen(ctx, t, modGen.Directory("."))
httpServer, _ := httpService(ctx, t, c, "im up")
endpoint, err := httpServer.Endpoint(ctx)
require.NoError(t, err)
out, err := modGen.
WithServiceBinding("testserver", httpServer).
With(daggerCall("fn", "--svc", "tcp://"+endpoint)).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "1 exposed ports:\n- TCP/8000", out)
})
})
t.Run("list args", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("foo.txt", dagger.ContainerWithNewFileOpts{
Contents: "bar",
}).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
"strings"
)
type Minimal struct {}
func (m *Minimal) Hello(msgs []string) string {
return strings.Join(msgs, "+")
}
func (m *Minimal) Reads(ctx context.Context, files []File) (string, error) {
var contents []string
for _, f := range files {
content, err := f.Contents(ctx)
if err != nil {
return "", err
}
contents = append(contents, content)
}
return strings.Join(contents, "+"), nil
}
`,
})
logGen(ctx, t, modGen.Directory("."))
out, err := modGen.With(daggerCall("hello", "--msgs", "yo", "--msgs", "my", "--msgs", "friend")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "yo+my+friend", out)
out, err = modGen.With(daggerCall("reads", "--files=foo.txt", "--files=foo.txt")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "bar+bar", out)
})
t.Run("directory arg inputs", func(t *testing.T) {
t.Parallel()
t.Run("local dir", func(t *testing.T) {
t.Parallel()
t.Run("abs path", func(t *testing.T) {
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("/dir/subdir/foo.txt", dagger.ContainerWithNewFileOpts{
Contents: "foo",
}).
WithNewFile("/dir/subdir/bar.txt", dagger.ContainerWithNewFileOpts{
Contents: "bar",
}).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct {}
func (m *Test) Fn(dir *Directory) *Directory {
return dir
}
`,
})
out, err := modGen.With(daggerCall("fn", "--dir", "/dir/subdir", "entries")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "bar.txt\nfoo.txt\n", out)
out, err = modGen.With(daggerCall("fn", "--dir", "file:///dir/subdir", "entries")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "bar.txt\nfoo.txt\n", out)
})
t.Run("rel path", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dir").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("/work/otherdir/foo.txt", dagger.ContainerWithNewFileOpts{
Contents: "foo",
}).
WithNewFile("/work/otherdir/bar.txt", dagger.ContainerWithNewFileOpts{
Contents: "bar",
}).
WithNewFile("/work/dir/subdir/blah.txt", dagger.ContainerWithNewFileOpts{
Contents: "blah",
}).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct {}
func (m *Test) Fn(dir *Directory) *Directory {
return dir
}
`,
})
out, err := modGen.With(daggerCall("fn", "--dir", "../otherdir", "entries")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "bar.txt\nfoo.txt\n", out)
out, err = modGen.With(daggerCall("fn", "--dir", "file://../otherdir", "entries")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "bar.txt\nfoo.txt\n", out)
out, err = modGen.With(daggerCall("fn", "--dir", "subdir", "entries")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "blah.txt\n", out)
out, err = modGen.With(daggerCall("fn", "--dir", "file://subdir", "entries")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "blah.txt\n", out)
})
})
t.Run("git dir", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct {}
func (m *Test) Fn(
dir *Directory,
subpath string, // +optional
) *Directory {
if subpath == "" {
subpath = "."
}
return dir.Directory(subpath)
}
`,
})
for _, tc := range []struct {
baseURL string
subpath string
}{
{
baseURL: "https://github.com/dagger/dagger",
},
{
baseURL: "https://github.com/dagger/dagger",
subpath: ".changes",
},
{
baseURL: "https://github.com/dagger/dagger.git",
},
{
baseURL: "https://github.com/dagger/dagger.git",
subpath: ".changes",
},
} {
tc := tc
t.Run(fmt.Sprintf("%s:%s", tc.baseURL, tc.subpath), func(t *testing.T) {
url := tc.baseURL + "#v0.9.1"
if tc.subpath != "" {
url += ":" + tc.subpath
}
args := []string{"fn", "--dir", url}
if tc.subpath == "" {
args = append(args, "--subpath", ".changes")
}
args = append(args, "entries")
out, err := modGen.With(daggerCall(args...)).Stdout(ctx)
require.NoError(t, err)
require.Contains(t, out, "v0.9.1.md")
require.NotContains(t, out, "v0.9.2.md")
})
}
})
})
t.Run("file arg inputs", func(t *testing.T) {
t.Parallel()
t.Run("abs path", func(t *testing.T) {
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("/dir/subdir/foo.txt", dagger.ContainerWithNewFileOpts{
Contents: "foo",
}).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct {}
func (m *Test) Fn(file *File) *File {
return file
}
`,
})
out, err := modGen.With(daggerCall("fn", "--file", "/dir/subdir/foo.txt", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "foo", out)
out, err = modGen.With(daggerCall("fn", "--file", "file:///dir/subdir/foo.txt", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "foo", out)
})
t.Run("rel path", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := goGitBase(t, c).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/dir").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("/work/otherdir/foo.txt", dagger.ContainerWithNewFileOpts{
Contents: "foo",
}).
WithNewFile("/work/dir/subdir/blah.txt", dagger.ContainerWithNewFileOpts{
Contents: "blah",
}).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct {}
func (m *Test) Fn(file *File) *File {
return file
}
`,
})
out, err := modGen.With(daggerCall("fn", "--file", "../otherdir/foo.txt", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "foo", out)
out, err = modGen.With(daggerCall("fn", "--file", "file://../otherdir/foo.txt", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "foo", out)
out, err = modGen.With(daggerCall("fn", "--file", "subdir/blah.txt", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "blah", out)
out, err = modGen.With(daggerCall("fn", "--file", "file://subdir/blah.txt", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "blah", out)
})
})
t.Run("secret args", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "context"
type Test struct {}
func (m *Test) Insecure(ctx context.Context, token *Secret) (string, error) {
return token.Plaintext(ctx)
}
`,
}).
WithEnvVariable("TOPSECRET", "shhh").
WithNewFile("/mysupersecret", dagger.ContainerWithNewFileOpts{Contents: "file shhh"})
t.Run("explicit env", func(t *testing.T) {
t.Run("happy", func(t *testing.T) {
out, err := modGen.With(daggerCall("insecure", "--token", "env:TOPSECRET")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "shhh", out)
})
t.Run("sad", func(t *testing.T) {
_, err := modGen.With(daggerCall("insecure", "--token", "env:NOWHERETOBEFOUND")).Stdout(ctx)
require.ErrorContains(t, err, `secret env var not found: "NOW..."`)
})
})
t.Run("implicit env", func(t *testing.T) {
t.Parallel()
t.Run("happy", func(t *testing.T) {
out, err := modGen.With(daggerCall("insecure", "--token", "TOPSECRET")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "shhh", out)
})
t.Run("sad", func(t *testing.T) {
_, err := modGen.With(daggerCall("insecure", "--token", "NOWHERETOBEFOUND")).Stdout(ctx)
require.ErrorContains(t, err, `secret env var not found: "NOW..."`)
})
})
t.Run("file", func(t *testing.T) {
t.Run("happy", func(t *testing.T) {
out, err := modGen.With(daggerCall("insecure", "--token", "file:/mysupersecret")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "file shhh", out)
})
t.Run("sad", func(t *testing.T) {
_, err := modGen.With(daggerCall("insecure", "--token", "file:/nowheretobefound")).Stdout(ctx)
require.ErrorContains(t, err, `failed to read secret file "/nowheretobefound": open /nowheretobefound: no such file or directory`)
})
})
t.Run("cmd", func(t *testing.T) {
t.Run("happy", func(t *testing.T) {
out, err := modGen.With(daggerCall("insecure", "--token", "cmd:echo -n cmd shhh")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "cmd shhh", out)
})
t.Run("sad", func(t *testing.T) {
_, err := modGen.With(daggerCall("insecure", "--token", "cmd:exit 1")).Stdout(ctx)
require.ErrorContains(t, err, `failed to run secret command "exit 1": exit status 1`)
})
})
t.Run("invalid source", func(t *testing.T) {
_, err := modGen.With(daggerCall("insecure", "--token", "wtf:HUH")).Stdout(ctx)
require.ErrorContains(t, err, `unsupported secret arg source: "wtf"`)
})
})
t.Run("cache volume args", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
volName := identity.NewID()
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import (
"context"
)
type Test struct {}
func (m *Test) Cacher(ctx context.Context, cache *CacheVolume, val string) (string, error) {
return dag.Container().
From("` + alpineImage + `").
WithMountedCache("/cache", cache).
WithExec([]string{"sh", "-c", "echo $0 >> /cache/vals", val}).
WithExec([]string{"cat", "/cache/vals"}).
Stdout(ctx)
}
`,
})
out, err := modGen.With(daggerCall("cacher", "--cache", volName, "--val", "foo")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "foo\n", out)
out, err = modGen.With(daggerCall("cacher", "--cache", volName, "--val", "bar")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "foo\nbar\n", out)
})
}
func TestModuleDaggerCallReturnTypes(t *testing.T) {
t.Parallel()
t.Run("return list objects", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=minimal", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Minimal struct {}
type Foo struct {
Bar int ` + "`" + `json:"bar"` + "`" + `
}
func (m *Minimal) Fn() []*Foo {
var foos []*Foo
for i := 0; i < 3; i++ {
foos = append(foos, &Foo{Bar: i})
}
return foos
}
`,
})
logGen(ctx, t, modGen.Directory("."))
expected := "0\n1\n2\n"
t.Run("print", func(t *testing.T) {
out, err := modGen.With(daggerCall("fn", "bar")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, expected, out)
})
t.Run("output", func(t *testing.T) {
out, err := modGen.
With(daggerCall("fn", "bar", "-o", "./outfile")).
File("./outfile").
Contents(ctx)
require.NoError(t, err)
require.Equal(t, expected, out)
})
t.Run("json", func(t *testing.T) {
out, err := modGen.
With(daggerCall("fn", "bar", "--json")).
Stdout(ctx)
require.NoError(t, err)
require.JSONEq(t, `[{"bar": 0}, {"bar": 1}, {"bar": 2}]`, out)
})
})
t.Run("return container", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
func New() *Test {
return &Test{Ctr: dag.Container().From("alpine:3.18").WithExec([]string{"echo", "hello", "world"})}
}
type Test struct {
Ctr *Container
}
`,
})
logGen(ctx, t, modGen.Directory("."))
t.Run("default", func(t *testing.T) {
ctr := modGen.With(daggerCall("ctr"))
out, err := ctr.Stdout(ctx)
require.NoError(t, err)
require.Empty(t, out)
out, err = ctr.Stderr(ctx)
require.NoError(t, err)
require.Contains(t, out, "Container evaluated")
})
t.Run("output", func(t *testing.T) {
modGen, err := modGen.With(daggerCall("ctr", "-o", "./container.tar")).Sync(ctx)
require.NoError(t, err)
size, err := modGen.File("./container.tar").Size(ctx)
require.NoError(t, err)
require.Greater(t, size, 0)
_, err = modGen.WithExec([]string{"tar", "tf", "./container.tar", "oci-layout"}).Sync(ctx)
require.NoError(t, err)
})
})
t.Run("return directory", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
func New() *Test {
return &Test{
Dir: dag.Directory().WithNewFile("foo.txt", "foo").WithNewFile("bar.txt", "bar"),
}
}
type Test struct {
Dir *Directory
}
`,
})
logGen(ctx, t, modGen.Directory("."))
t.Run("default", func(t *testing.T) {
ctr := modGen.With(daggerCall("dir"))
out, err := ctr.Stdout(ctx)
require.NoError(t, err)
require.Empty(t, out)
out, err = ctr.Stderr(ctx)
require.NoError(t, err)
require.Contains(t, out, "Directory evaluated")
})
t.Run("output", func(t *testing.T) {
modGen, err := modGen.With(daggerCall("dir", "-o", "./outdir")).Sync(ctx)
require.NoError(t, err)
entries, err := modGen.Directory("./outdir").Entries(ctx)
require.NoError(t, err)
require.Equal(t, "bar.txt\nfoo.txt", strings.Join(entries, "\n"))
foo, err := modGen.Directory("./outdir").File("foo.txt").Contents(ctx)
require.NoError(t, err)
require.Equal(t, "foo", foo)
bar, err := modGen.Directory("./outdir").File("bar.txt").Contents(ctx)
require.NoError(t, err)
require.Equal(t, "bar", bar)
})
})
t.Run("return file", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
func New() *Test {
return &Test{
File: dag.Directory().WithNewFile("foo.txt", "foo").File("foo.txt"),
}
}
type Test struct {
File *File
}
`,
})
logGen(ctx, t, modGen.Directory("."))
t.Run("default", func(t *testing.T) {
ctr := modGen.With(daggerCall("file"))
out, err := ctr.Stdout(ctx)
require.NoError(t, err)
require.Empty(t, out)
out, err = ctr.Stderr(ctx)
require.NoError(t, err)
require.Contains(t, out, "File evaluated")
})
t.Run("output", func(t *testing.T) {
out, err := modGen.
With(daggerCall("file", "-o", "./outfile")).
File("./outfile").
Contents(ctx)
require.NoError(t, err)
require.Equal(t, "foo", out)
})
})
t.Run("sync", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
func New() *Test {
return &Test{Ctr: dag.Container().From("alpine:3.18").WithExec([]string{"echo", "hello", "world"})}
}
type Test struct {
Ctr *Container
}
`,
})
// adding sync disables the default behavior of **not** printing the ID
// just verify it works without error for now
_, err := modGen.With(daggerCall("ctr", "sync")).Stdout(ctx)
require.NoError(t, err)
})
}
func TestModuleDaggerCallCoreChaining(t *testing.T) {
t.Parallel()
t.Run("container", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
func New() *Test {
return &Test{Ctr: dag.Container().From("alpine:3.18.5")}
}
type Test struct {
Ctr *Container
}
`,
})
t.Run("file", func(t *testing.T) {
out, err := modGen.With(daggerCall("ctr", "file", "--path=/etc/alpine-release", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "3.18.5\n", out)
})
t.Run("export", func(t *testing.T) {
modGen, err := modGen.With(daggerCall("ctr", "export", "--path=./container.tar.gz")).Sync(ctx)
require.NoError(t, err)
size, err := modGen.File("./container.tar.gz").Size(ctx)
require.NoError(t, err)
require.Greater(t, size, 0)
})
})
t.Run("directory", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
func New() *Test {
return &Test{
Dir: dag.Directory().WithNewFile("foo.txt", "foo").WithNewFile("bar.txt", "bar"),
}
}
type Test struct {
Dir *Directory
}
`,
})
t.Run("file", func(t *testing.T) {
out, err := modGen.With(daggerCall("dir", "file", "--path=foo.txt", "contents")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "foo", out)
})
t.Run("export", func(t *testing.T) {
modGen, err := modGen.With(daggerCall("dir", "export", "--path=./outdir")).Sync(ctx)
require.NoError(t, err)
ents, err := modGen.Directory("./outdir").Entries(ctx)
require.NoError(t, err)
require.Equal(t, []string{"bar.txt", "foo.txt"}, ents)
})
})
t.Run("return file", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
func New() *Test {
return &Test{
File: dag.Directory().WithNewFile("foo.txt", "foo").File("foo.txt"),
}
}
type Test struct {
File *File
}
`,
})
t.Run("size", func(t *testing.T) {
out, err := modGen.With(daggerCall("file", "size")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "3", out)
})
t.Run("export", func(t *testing.T) {
modGen, err := modGen.With(daggerCall("file", "export", "--path=./outfile")).Sync(ctx)
require.NoError(t, err)
contents, err := modGen.File("./outfile").Contents(ctx)
require.NoError(t, err)
require.Equal(t, "foo", contents)
})
})
}
func TestModuleDaggerCallSaveOutput(t *testing.T) {
// NB: Normal usage is tested in TestModuleDaggerCallReturnTypes.
t.Parallel()
c, ctx := connect(t)
modGen := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init", "--source=.", "--name=test", "--sdk=go")).
WithNewFile("main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
type Test struct {
}
func (t *Test) Hello() string {
return "hello"
}
func (t *Test) File() *File {
return dag.Directory().WithNewFile("foo.txt", "foo").File("foo.txt")
}
`,
})
logGen(ctx, t, modGen.Directory("."))
t.Run("truncate file", func(t *testing.T) {
out, err := modGen.
WithNewFile("foo.txt", dagger.ContainerWithNewFileOpts{
Contents: "foobar",
}).
With(daggerCall("hello", "-o", "foo.txt")).
File("foo.txt").
Contents(ctx)
require.NoError(t, err)
require.Equal(t, "hello", out)
})
t.Run("not a file", func(t *testing.T) {
_, err := modGen.With(daggerCall("hello", "-o", ".")).Sync(ctx)
require.ErrorContains(t, err, "is a directory")
})
t.Run("allow dir for file", func(t *testing.T) {
out, err := modGen.
With(daggerCall("file", "-o", ".")).
File("foo.txt").
Contents(ctx)
require.NoError(t, err)
require.Equal(t, "foo", out)
})
t.Run("create parent dirs", func(t *testing.T) {
ctr, err := modGen.With(daggerCall("hello", "-o", "foo/bar.txt")).Sync(ctx)
require.NoError(t, err)
t.Run("print success", func(t *testing.T) {
// should print success to stderr so it doesn't interfere with piping output
out, err := ctr.Stderr(ctx)
require.NoError(t, err)
require.Contains(t, out, `Saved output to "/work/foo/bar.txt"`)
})
t.Run("check directory permissions", func(t *testing.T) {
out, err := ctr.WithExec([]string{"stat", "-c", "%a", "foo"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "755\n", out)
})
t.Run("check file permissions", func(t *testing.T) {
out, err := ctr.WithExec([]string{"stat", "-c", "%a", "foo/bar.txt"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "644\n", out)
})
})
t.Run("check umask", func(t *testing.T) {
ctr, err := modGen.
WithNewFile("/entrypoint.sh", dagger.ContainerWithNewFileOpts{
Contents: `#!/bin/sh
umask 027
exec "$@"
`,
Permissions: 0o750,
}).
WithEntrypoint([]string{"/entrypoint.sh"}).
With(daggerCall("hello", "-o", "/tmp/foo/bar.txt")).
Sync(ctx)
require.NoError(t, err)
t.Run("directory", func(t *testing.T) {
out, err := ctr.WithExec([]string{"stat", "-c", "%a", "/tmp/foo"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "750\n", out)
})
t.Run("file", func(t *testing.T) {
out, err := ctr.WithExec([]string{"stat", "-c", "%a", "/tmp/foo/bar.txt"}).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "640\n", out)
})
})
}
func TestModuleCallByName(t *testing.T) {
t.Parallel()
t.Run("local", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work/mod-a").
With(daggerExec("init", "--source=.", "--name=mod-a", "--sdk=go")).
WithNewFile("/work/mod-a/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "context"
type ModA struct {}
func (m *ModA) Fn(ctx context.Context) string {
return "hi from mod-a"
}
`,
}).
WithWorkdir("/work/mod-b").
With(daggerExec("init", "--source=.", "--name=mod-b", "--sdk=go")).
WithNewFile("/work/mod-b/main.go", dagger.ContainerWithNewFileOpts{
Contents: `package main
import "context"
type ModB struct {}
func (m *ModB) Fn(ctx context.Context) string {
return "hi from mod-b"
}
`,
}).
WithWorkdir("/work").
With(daggerExec("init")).
With(daggerExec("install", "--name", "foo", "./mod-a")).
With(daggerExec("install", "--name", "bar", "./mod-b"))
out, err := ctr.With(daggerCallAt("foo", "fn")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "hi from mod-a", strings.TrimSpace(out))
out, err = ctr.With(daggerCallAt("bar", "fn")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "hi from mod-b", strings.TrimSpace(out))
})
t.Run("git", func(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
ctr := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
WithWorkdir("/work").
With(daggerExec("init")).
With(daggerExec("install", "--name", "foo", testGitModuleRef(""))).
With(daggerExec("install", "--name", "bar", testGitModuleRef("subdir/dep2")))
out, err := ctr.With(daggerCallAt("foo", "fn")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "hi from root hi from dep hi from dep2", strings.TrimSpace(out))
out, err = ctr.With(daggerCallAt("bar", "fn")).Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "hi from dep2", strings.TrimSpace(out))
})
}
func TestModuleCallGitMod(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
out, err := c.Container().From(golangImage).
WithMountedFile(testCLIBinPath, daggerCliFile(t, c)).
With(daggerCallAt(testGitModuleRef("top-level"), "fn")).
Stdout(ctx)
require.NoError(t, err)
require.Equal(t, "hi from top level hi from dep hi from dep2", strings.TrimSpace(out))
}
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,743 | 🐞 grpc: received message larger than max | ### What is the issue?
seeing these panics, running 0.9.11 dagger-engine, 0.9.11 dagger CLI, and 0.9.11 client:
```2024/02/26 21:24:05 http: panic serving 127.0.0.1:52322: rpc error: code = ResourceExhausted desc = grpc: received message larger than max (65067251 vs. 16777216)
goroutine 760 [running]:
net/http.(*conn).serve.func1()
/usr/local/go/src/net/http/server.go:1868 +0xb0
panic({0xd0af20?, 0x4000092b70?})
/usr/local/go/src/runtime/panic.go:920 +0x26c
github.com/dagger/dagger/engine/client.(*Client).ServeHTTP(0x40004169c0, {0x1068960, 0x4000606000}, 0x40004e0000)
/app/engine/client/client.go:558 +0xa7c
net/http.serverHandler.ServeHTTP({0x1064768?}, {0x1068960?, 0x4000606000?}, 0x6?)
/usr/local/go/src/net/http/server.go:2938 +0xbc
net/http.(*conn).serve(0x40001298c0, {0x106e768, 0x40003e4fc0})
/usr/local/go/src/net/http/server.go:2009 +0x518
created by net/http.(*Server).Serve in goroutine 67
/usr/local/go/src/net/http/server.go:3086 +0x4cc
```
### Dagger version
dagger v0.9.11 (registry.dagger.io/engine) linux/amd64
### Steps to reproduce
load contents of a dagger.Container's File, where the file is large, largest file in my manifest is 70546316 bytes:
```
fmt.Printf("starting transfer for %s: %s\n", deb_pkg, time.Now())
deb_data, err := testImage.File(deb_pkg).Contents(ctx)
if err != nil {
panic(err)
}
```
### Log output
_No response_ | https://github.com/dagger/dagger/issues/6743 | https://github.com/dagger/dagger/pull/6772 | 7d606df4623db4f7ca9a5c28607e2d811263cf39 | 18c8c420d7c309c8f3735e985170a184a8b62d56 | "2024-02-26T21:54:40Z" | go | "2024-03-05T10:02:01Z" | .changes/unreleased/Fixed-20240228-155029.yaml | |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,743 | 🐞 grpc: received message larger than max | ### What is the issue?
seeing these panics, running 0.9.11 dagger-engine, 0.9.11 dagger CLI, and 0.9.11 client:
```2024/02/26 21:24:05 http: panic serving 127.0.0.1:52322: rpc error: code = ResourceExhausted desc = grpc: received message larger than max (65067251 vs. 16777216)
goroutine 760 [running]:
net/http.(*conn).serve.func1()
/usr/local/go/src/net/http/server.go:1868 +0xb0
panic({0xd0af20?, 0x4000092b70?})
/usr/local/go/src/runtime/panic.go:920 +0x26c
github.com/dagger/dagger/engine/client.(*Client).ServeHTTP(0x40004169c0, {0x1068960, 0x4000606000}, 0x40004e0000)
/app/engine/client/client.go:558 +0xa7c
net/http.serverHandler.ServeHTTP({0x1064768?}, {0x1068960?, 0x4000606000?}, 0x6?)
/usr/local/go/src/net/http/server.go:2938 +0xbc
net/http.(*conn).serve(0x40001298c0, {0x106e768, 0x40003e4fc0})
/usr/local/go/src/net/http/server.go:2009 +0x518
created by net/http.(*Server).Serve in goroutine 67
/usr/local/go/src/net/http/server.go:3086 +0x4cc
```
### Dagger version
dagger v0.9.11 (registry.dagger.io/engine) linux/amd64
### Steps to reproduce
load contents of a dagger.Container's File, where the file is large, largest file in my manifest is 70546316 bytes:
```
fmt.Printf("starting transfer for %s: %s\n", deb_pkg, time.Now())
deb_data, err := testImage.File(deb_pkg).Contents(ctx)
if err != nil {
panic(err)
}
```
### Log output
_No response_ | https://github.com/dagger/dagger/issues/6743 | https://github.com/dagger/dagger/pull/6772 | 7d606df4623db4f7ca9a5c28607e2d811263cf39 | 18c8c420d7c309c8f3735e985170a184a8b62d56 | "2024-02-26T21:54:40Z" | go | "2024-03-05T10:02:01Z" | core/integration/file_test.go | package core
import (
"bytes"
"fmt"
"os"
"path/filepath"
"strconv"
"strings"
"testing"
"time"
"dagger.io/dagger"
"github.com/dagger/dagger/core"
"github.com/dagger/dagger/engine/buildkit"
"github.com/dagger/dagger/internal/testutil"
"github.com/moby/buildkit/identity"
"github.com/stretchr/testify/require"
)
func TestFile(t *testing.T) {
t.Parallel()
var res struct {
Directory struct {
WithNewFile struct {
File struct {
ID core.FileID
Contents string
}
}
}
}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-file", contents: "some-content") {
file(path: "some-file") {
id
contents
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.NotEmpty(t, res.Directory.WithNewFile.File.ID)
require.Equal(t, "some-content", res.Directory.WithNewFile.File.Contents)
}
func TestDirectoryFile(t *testing.T) {
t.Parallel()
var res struct {
Directory struct {
WithNewFile struct {
Directory struct {
File struct {
ID core.FileID
Contents string
}
}
}
}
}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-dir/some-file", contents: "some-content") {
directory(path: "some-dir") {
file(path: "some-file") {
id
contents
}
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.NotEmpty(t, res.Directory.WithNewFile.Directory.File.ID)
require.Equal(t, "some-content", res.Directory.WithNewFile.Directory.File.Contents)
}
func TestFileSize(t *testing.T) {
t.Parallel()
var res struct {
Directory struct {
WithNewFile struct {
File struct {
ID core.FileID
Size int
}
}
}
}
err := testutil.Query(
`{
directory {
withNewFile(path: "some-file", contents: "some-content") {
file(path: "some-file") {
id
size
}
}
}
}`, &res, nil)
require.NoError(t, err)
require.NotEmpty(t, res.Directory.WithNewFile.File.ID)
require.Equal(t, len("some-content"), res.Directory.WithNewFile.File.Size)
}
func TestFileName(t *testing.T) {
t.Parallel()
wd := t.TempDir()
c, ctx := connect(t, dagger.WithWorkdir(wd))
t.Run("new file", func(t *testing.T) {
t.Parallel()
file := c.Directory().WithNewFile("/foo/bar", "content1").File("foo/bar")
name, err := file.Name(ctx)
require.NoError(t, err)
require.Equal(t, "bar", name)
})
t.Run("container file", func(t *testing.T) {
t.Parallel()
file := c.Container().From(alpineImage).File("/etc/alpine-release")
name, err := file.Name(ctx)
require.NoError(t, err)
require.Equal(t, "alpine-release", name)
})
t.Run("container file in dir", func(t *testing.T) {
t.Parallel()
file := c.Container().From(alpineImage).Directory("/etc").File("/alpine-release")
name, err := file.Name(ctx)
require.NoError(t, err)
require.Equal(t, "alpine-release", name)
})
t.Run("host file", func(t *testing.T) {
t.Parallel()
err := os.WriteFile(filepath.Join(wd, "file.txt"), []byte{}, 0o600)
require.NoError(t, err)
name, err := c.Host().File("file.txt").Name(ctx)
require.NoError(t, err)
require.Equal(t, "file.txt", name)
})
t.Run("host file in dir", func(t *testing.T) {
t.Parallel()
err := os.MkdirAll(filepath.Join(wd, "path/to/"), 0o700)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(wd, "path/to/file.txt"), []byte{}, 0o600)
require.NoError(t, err)
name, err := c.Host().Directory("path").File("to/file.txt").Name(ctx)
require.NoError(t, err)
require.Equal(t, "file.txt", name)
})
}
func TestFileExport(t *testing.T) {
t.Parallel()
wd := t.TempDir()
targetDir := t.TempDir()
c, ctx := connect(t, dagger.WithWorkdir(wd))
file := c.Container().From(alpineImage).File("/etc/alpine-release")
t.Run("to absolute path", func(t *testing.T) {
dest := filepath.Join(targetDir, "some-file")
ok, err := file.Export(ctx, dest)
require.NoError(t, err)
require.True(t, ok)
contents, err := os.ReadFile(dest)
require.NoError(t, err)
require.Equal(t, "3.18.2\n", string(contents))
entries, err := ls(targetDir)
require.NoError(t, err)
require.Len(t, entries, 1)
})
t.Run("to relative path", func(t *testing.T) {
ok, err := file.Export(ctx, "some-file")
require.NoError(t, err)
require.True(t, ok)
contents, err := os.ReadFile(filepath.Join(wd, "some-file"))
require.NoError(t, err)
require.Equal(t, "3.18.2\n", string(contents))
entries, err := ls(wd)
require.NoError(t, err)
require.Len(t, entries, 1)
})
t.Run("to path in outer dir", func(t *testing.T) {
ok, err := file.Export(ctx, "../some-file")
require.Error(t, err)
require.False(t, ok)
})
t.Run("to absolute dir", func(t *testing.T) {
ok, err := file.Export(ctx, targetDir)
require.Error(t, err)
require.False(t, ok)
})
t.Run("to workdir", func(t *testing.T) {
ok, err := file.Export(ctx, ".")
require.Error(t, err)
require.False(t, ok)
})
t.Run("file under subdir", func(t *testing.T) {
dir := c.Directory().
WithNewFile("/file", "content1").
WithNewFile("/subdir/file", "content2")
file := dir.File("/subdir/file")
dest := filepath.Join(targetDir, "da-file")
_, err := file.Export(ctx, dest)
require.NoError(t, err)
contents, err := os.ReadFile(dest)
require.NoError(t, err)
require.Equal(t, "content2", string(contents))
dir = dir.Directory("/subdir")
file = dir.File("file")
dest = filepath.Join(targetDir, "da-file-2")
_, err = file.Export(ctx, dest)
require.NoError(t, err)
contents, err = os.ReadFile(dest)
require.NoError(t, err)
require.Equal(t, "content2", string(contents))
})
t.Run("file larger than max chunk size", func(t *testing.T) {
maxChunkSize := buildkit.MaxFileContentsChunkSize
fileSizeBytes := maxChunkSize*4 + 1 // +1 so it's not an exact number of chunks, to ensure we cover that case
_, err := c.Container().From(alpineImage).WithExec([]string{"sh", "-c",
fmt.Sprintf("dd if=/dev/zero of=/file bs=%d count=1", fileSizeBytes)}).
File("/file").Export(ctx, "some-pretty-big-file")
require.NoError(t, err)
stat, err := os.Stat(filepath.Join(wd, "some-pretty-big-file"))
require.NoError(t, err)
require.EqualValues(t, fileSizeBytes, stat.Size())
})
t.Run("file permissions are retained", func(t *testing.T) {
_, err := c.Directory().WithNewFile("/file", "#!/bin/sh\necho hello", dagger.DirectoryWithNewFileOpts{
Permissions: 0744,
}).File("/file").Export(ctx, "some-executable-file")
require.NoError(t, err)
stat, err := os.Stat(filepath.Join(wd, "some-executable-file"))
require.NoError(t, err)
require.EqualValues(t, 0744, stat.Mode().Perm())
})
}
func TestFileWithTimestamps(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
reallyImportantTime := time.Date(1985, 10, 26, 8, 15, 0, 0, time.UTC)
file := c.Directory().
WithNewFile("sub-dir/sub-file", "sub-content").
File("sub-dir/sub-file").
WithTimestamps(int(reallyImportantTime.Unix()))
ls, err := c.Container().
From(alpineImage).
WithMountedFile("/file", file).
WithEnvVariable("RANDOM", identity.NewID()).
WithExec([]string{"stat", "/file"}).
Stdout(ctx)
require.NoError(t, err)
require.Contains(t, ls, "Access: 1985-10-26 08:15:00.000000000 +0000")
require.Contains(t, ls, "Modify: 1985-10-26 08:15:00.000000000 +0000")
}
func TestFileContents(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
// Set three types of file sizes for test data,
// the third one uses a size larger than the max chunk size:
testFiles := []struct {
size int
hash string
}{
{size: buildkit.MaxFileContentsChunkSize / 2},
{size: buildkit.MaxFileContentsChunkSize},
{size: buildkit.MaxFileContentsChunkSize * 2},
{size: buildkit.MaxFileContentsSize + 1},
}
tempDir := t.TempDir()
for i, testFile := range testFiles {
filename := strconv.Itoa(i)
dest := filepath.Join(tempDir, filename)
var buf bytes.Buffer
for i := 0; i < testFile.size; i++ {
buf.WriteByte('a')
}
err := os.WriteFile(dest, buf.Bytes(), 0o600)
require.NoError(t, err)
// Compute and store hash for generated test data:
testFiles[i].hash = computeMD5FromReader(&buf)
}
hostDir := c.Host().Directory(tempDir)
alpine := c.Container().
From(alpineImage).WithDirectory(".", hostDir)
// Grab file contents and compare hashes to validate integrity:
for i, testFile := range testFiles {
filename := strconv.Itoa(i)
contents, err := alpine.File(filename).Contents(ctx)
// Assert error on larger files:
if testFile.size > buildkit.MaxFileContentsSize {
require.Error(t, err)
continue
}
require.NoError(t, err)
contentsHash := computeMD5FromReader(strings.NewReader(contents))
require.Equal(t, testFile.hash, contentsHash)
}
}
func TestFileSync(t *testing.T) {
t.Parallel()
c, ctx := connect(t)
t.Run("triggers error", func(t *testing.T) {
_, err := c.Directory().File("baz").Sync(ctx)
require.Error(t, err)
require.Contains(t, err.Error(), "no such file")
_, err = c.Container().From(alpineImage).File("/bar").Sync(ctx)
require.Error(t, err)
require.Contains(t, err.Error(), "no such file")
})
t.Run("allows chaining", func(t *testing.T) {
file, err := c.Directory().WithNewFile("foo", "bar").File("foo").Sync(ctx)
require.NoError(t, err)
contents, err := file.Contents(ctx)
require.NoError(t, err)
require.Equal(t, "bar", contents)
})
}
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,743 | 🐞 grpc: received message larger than max | ### What is the issue?
seeing these panics, running 0.9.11 dagger-engine, 0.9.11 dagger CLI, and 0.9.11 client:
```2024/02/26 21:24:05 http: panic serving 127.0.0.1:52322: rpc error: code = ResourceExhausted desc = grpc: received message larger than max (65067251 vs. 16777216)
goroutine 760 [running]:
net/http.(*conn).serve.func1()
/usr/local/go/src/net/http/server.go:1868 +0xb0
panic({0xd0af20?, 0x4000092b70?})
/usr/local/go/src/runtime/panic.go:920 +0x26c
github.com/dagger/dagger/engine/client.(*Client).ServeHTTP(0x40004169c0, {0x1068960, 0x4000606000}, 0x40004e0000)
/app/engine/client/client.go:558 +0xa7c
net/http.serverHandler.ServeHTTP({0x1064768?}, {0x1068960?, 0x4000606000?}, 0x6?)
/usr/local/go/src/net/http/server.go:2938 +0xbc
net/http.(*conn).serve(0x40001298c0, {0x106e768, 0x40003e4fc0})
/usr/local/go/src/net/http/server.go:2009 +0x518
created by net/http.(*Server).Serve in goroutine 67
/usr/local/go/src/net/http/server.go:3086 +0x4cc
```
### Dagger version
dagger v0.9.11 (registry.dagger.io/engine) linux/amd64
### Steps to reproduce
load contents of a dagger.Container's File, where the file is large, largest file in my manifest is 70546316 bytes:
```
fmt.Printf("starting transfer for %s: %s\n", deb_pkg, time.Now())
deb_data, err := testImage.File(deb_pkg).Contents(ctx)
if err != nil {
panic(err)
}
```
### Log output
_No response_ | https://github.com/dagger/dagger/issues/6743 | https://github.com/dagger/dagger/pull/6772 | 7d606df4623db4f7ca9a5c28607e2d811263cf39 | 18c8c420d7c309c8f3735e985170a184a8b62d56 | "2024-02-26T21:54:40Z" | go | "2024-03-05T10:02:01Z" | engine/server/server.go | package server
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"net"
"net/http"
"os"
"sync"
"time"
"github.com/dagger/dagger/analytics"
"github.com/dagger/dagger/auth"
"github.com/dagger/dagger/core"
"github.com/dagger/dagger/core/pipeline"
"github.com/dagger/dagger/core/schema"
"github.com/dagger/dagger/engine"
"github.com/dagger/dagger/engine/buildkit"
bksession "github.com/moby/buildkit/session"
"github.com/moby/buildkit/util/bklog"
bkworker "github.com/moby/buildkit/worker"
"github.com/sirupsen/logrus"
"github.com/vito/progrock"
)
type DaggerServer struct {
serverID string
bkClient *buildkit.Client
worker bkworker.Worker
schema *schema.APIServer
recorder *progrock.Recorder
analytics analytics.Tracker
progCleanup func() error
doneCh chan struct{}
closeOnce sync.Once
connectedClients int
clientMu sync.RWMutex
}
func NewDaggerServer(
ctx context.Context,
bkClient *buildkit.Client,
worker bkworker.Worker,
caller bksession.Caller,
serverID string,
secretStore *core.SecretStore,
authProvider *auth.RegistryAuthProvider,
rootLabels []pipeline.Label,
cloudToken string,
doNotTrack bool,
) (*DaggerServer, error) {
srv := &DaggerServer{
serverID: serverID,
bkClient: bkClient,
worker: worker,
analytics: analytics.New(analytics.Config{
DoNotTrack: doNotTrack || analytics.DoNotTrack(),
Labels: rootLabels,
CloudToken: cloudToken,
}),
doneCh: make(chan struct{}, 1),
}
clientConn := caller.Conn()
progClient := progrock.NewProgressServiceClient(clientConn)
progUpdates, err := progClient.WriteUpdates(ctx)
if err != nil {
return nil, err
}
progWriter, progCleanup, err := buildkit.ProgrockForwarder(bkClient.ProgSockPath, progrock.MultiWriter{
progrock.NewRPCWriter(clientConn, progUpdates),
buildkit.ProgrockLogrusWriter{},
})
if err != nil {
return nil, err
}
srv.progCleanup = progCleanup
progrockLabels := []*progrock.Label{}
for _, label := range rootLabels {
progrockLabels = append(progrockLabels, &progrock.Label{
Name: label.Name,
Value: label.Value,
})
}
srv.recorder = progrock.NewRecorder(progWriter, progrock.WithLabels(progrockLabels...))
// NOTE: context.Background is used because if the provided context is canceled, buildkit can
// leave internal progress contexts open and leak goroutines.
bkClient.WriteStatusesTo(context.Background(), srv.recorder)
apiSchema, err := schema.New(ctx, schema.InitializeArgs{
BuildkitClient: srv.bkClient,
Platform: srv.worker.Platforms(true)[0],
ProgSockPath: bkClient.ProgSockPath,
OCIStore: srv.worker.ContentStore(),
LeaseManager: srv.worker.LeaseManager(),
Secrets: secretStore,
Auth: authProvider,
})
if err != nil {
return nil, err
}
srv.schema = apiSchema
return srv, nil
}
func (srv *DaggerServer) LogMetrics(l *logrus.Entry) *logrus.Entry {
srv.clientMu.RLock()
defer srv.clientMu.RUnlock()
return l.WithField(fmt.Sprintf("server-%s-client-count", srv.serverID), srv.connectedClients)
}
func (srv *DaggerServer) Close() {
defer srv.closeOnce.Do(func() {
close(srv.doneCh)
})
// mark all groups completed
srv.recorder.Complete()
// close the recorder so the UI exits
srv.recorder.Close()
srv.progCleanup()
// close the analytics recorder
srv.analytics.Close()
}
func (srv *DaggerServer) Wait(ctx context.Context) error {
select {
case <-ctx.Done():
return ctx.Err()
case <-srv.doneCh:
return nil
}
}
func (srv *DaggerServer) ServeClientConn(
ctx context.Context,
clientMetadata *engine.ClientMetadata,
conn net.Conn,
) error {
bklog.G(ctx).Trace("serve client conn")
defer bklog.G(ctx).Trace("done serving client conn")
srv.clientMu.Lock()
srv.connectedClients++
defer func() {
srv.clientMu.Lock()
srv.connectedClients--
srv.clientMu.Unlock()
}()
srv.clientMu.Unlock()
conn = newLogicalDeadlineConn(nopCloserConn{conn})
l := &singleConnListener{conn: conn, closeCh: make(chan struct{})}
go func() {
<-ctx.Done()
l.Close()
}()
// NOTE: not sure how inefficient making a new server per-request is, fix if it's meaningful.
// Maybe we could dynamically mux in more endpoints for each client or something
handler, err := srv.HTTPHandlerForClient(clientMetadata, conn, bklog.G(ctx))
if err != nil {
return fmt.Errorf("failed to create http handler: %w", err)
}
httpSrv := http.Server{
Handler: handler,
ReadHeaderTimeout: 30 * time.Second,
}
defer httpSrv.Close()
return httpSrv.Serve(l)
}
func (srv *DaggerServer) HTTPHandlerForClient(clientMetadata *engine.ClientMetadata, conn net.Conn, lg *logrus.Entry) (http.Handler, error) {
return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
defer func() {
lg.Trace("handler done")
}()
req = req.WithContext(bklog.WithLogger(req.Context(), lg))
bklog.G(req.Context()).Debugf("http handler for client conn to path %s", req.URL.Path)
defer bklog.G(req.Context()).Debugf("http handler for client conn done: %s", clientMetadata.ClientID)
req = req.WithContext(progrock.ToContext(req.Context(), srv.recorder))
req = req.WithContext(engine.ContextWithClientMetadata(req.Context(), clientMetadata))
req = req.WithContext(analytics.WithContext(req.Context(), srv.analytics))
srv.schema.ServeHTTP(w, req)
}), nil
}
// converts a pre-existing net.Conn into a net.Listener that returns the conn and then blocks
type singleConnListener struct {
conn net.Conn
l sync.Mutex
closeCh chan struct{}
closeOnce sync.Once
}
func (l *singleConnListener) Accept() (net.Conn, error) {
l.l.Lock()
if l.conn == nil {
l.l.Unlock()
<-l.closeCh
return nil, io.ErrClosedPipe
}
defer l.l.Unlock()
c := l.conn
l.conn = nil
return c, nil
}
func (l *singleConnListener) Addr() net.Addr {
return nil
}
func (l *singleConnListener) Close() error {
l.closeOnce.Do(func() {
close(l.closeCh)
})
return nil
}
type nopCloserConn struct {
net.Conn
}
func (nopCloserConn) Close() error {
return nil
}
// TODO: could also implement this upstream on:
// https://github.com/sipsma/buildkit/blob/fa11bf9e57a68e3b5252386fdf44042dd672949a/session/grpchijack/dial.go#L45-L45
type withDeadlineConn struct {
conn net.Conn
readDeadline time.Time
readers []func()
readBuf *bytes.Buffer
readEOF bool
readCond *sync.Cond
writeDeadline time.Time
writers []func()
writersL sync.Mutex
}
func newLogicalDeadlineConn(inner net.Conn) net.Conn {
c := &withDeadlineConn{
conn: inner,
readBuf: new(bytes.Buffer),
readCond: sync.NewCond(new(sync.Mutex)),
}
go func() {
for {
buf := make([]byte, 32*1024)
n, err := inner.Read(buf)
if err != nil {
c.readCond.L.Lock()
c.readEOF = true
c.readCond.L.Unlock()
c.readCond.Broadcast()
return
}
c.readCond.L.Lock()
c.readBuf.Write(buf[0:n])
c.readCond.Broadcast()
c.readCond.L.Unlock()
}
}()
return c
}
func (c *withDeadlineConn) Read(b []byte) (n int, err error) {
c.readCond.L.Lock()
if c.readEOF {
c.readCond.L.Unlock()
return 0, io.EOF
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
if !c.readDeadline.IsZero() {
if time.Now().After(c.readDeadline) {
c.readCond.L.Unlock()
// return early without calling inner Read
return 0, os.ErrDeadlineExceeded
}
go func() {
dt := time.Until(c.readDeadline)
if dt > 0 {
time.Sleep(dt)
}
cancel()
}()
}
// Keep track of the reader so a future SetReadDeadline can interrupt it.
c.readers = append(c.readers, cancel)
c.readCond.L.Unlock()
// Start a goroutine for the actual Read operation
read := make(chan struct{})
var rN int
var rerr error
go func() {
defer close(read)
c.readCond.L.Lock()
defer c.readCond.L.Unlock()
for ctx.Err() == nil {
if c.readEOF {
rerr = io.EOF
break
}
n, _ := c.readBuf.Read(b) // ignore EOF here
if n > 0 {
rN = n
break
}
c.readCond.Wait()
}
}()
// Wait for either Read to complete or the timeout
select {
case <-read:
return rN, rerr
case <-ctx.Done():
return 0, os.ErrDeadlineExceeded
}
}
func (c *withDeadlineConn) Write(b []byte) (n int, err error) {
c.writersL.Lock()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
if !c.writeDeadline.IsZero() {
if time.Now().After(c.writeDeadline) {
c.writersL.Unlock()
// return early without calling inner Write
return 0, os.ErrDeadlineExceeded
}
go func() {
dt := time.Until(c.writeDeadline)
if dt > 0 {
time.Sleep(dt)
}
cancel()
}()
}
// Keep track of the writer so a future SetWriteDeadline can interrupt it.
c.writers = append(c.writers, cancel)
c.writersL.Unlock()
// Start a goroutine for the actual Write operation
write := make(chan int, 1)
go func() {
n, err = c.conn.Write(b)
write <- 0
}()
// Wait for either Write to complete or the timeout
select {
case <-write:
return n, err
case <-ctx.Done():
return 0, os.ErrDeadlineExceeded
}
}
func (c *withDeadlineConn) Close() error {
return c.conn.Close()
}
func (c *withDeadlineConn) LocalAddr() net.Addr {
return c.conn.LocalAddr()
}
func (c *withDeadlineConn) RemoteAddr() net.Addr {
return c.conn.RemoteAddr()
}
func (c *withDeadlineConn) SetDeadline(t time.Time) error {
return errors.Join(
c.SetReadDeadline(t),
c.SetWriteDeadline(t),
)
}
func (c *withDeadlineConn) SetReadDeadline(t time.Time) error {
c.readCond.L.Lock()
c.readDeadline = t
readers := c.readers
c.readCond.L.Unlock()
if len(readers) > 0 && !t.IsZero() {
go func() {
dt := time.Until(c.readDeadline)
if dt > 0 {
time.Sleep(dt)
}
for _, cancel := range readers {
cancel()
}
}()
}
return nil
}
func (c *withDeadlineConn) SetWriteDeadline(t time.Time) error {
c.writersL.Lock()
c.writeDeadline = t
writers := c.writers
c.writersL.Unlock()
if len(writers) > 0 && !t.IsZero() {
go func() {
dt := time.Until(c.writeDeadline)
if dt > 0 {
time.Sleep(dt)
}
for _, cancel := range writers {
cancel()
}
}()
}
return nil
}
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,828 | Panic in `terminal` if no args set | Think this is a regression in v0.10.1 cc @TomChv
See https://github.com/dagger/dagger/pull/6805/files#r1513137070
```
goroutine 457496 [running]:
runtime/debug.Stack()
/usr/local/go/src/runtime/debug/stack.go:24 +0x5e
github.com/dagger/dagger/dagql.(*Server).resolvePath.func1()
/app/dagql/server.go:642 +0x74
panic({0x1bd65a0?, 0x3139130?})
/usr/local/go/src/runtime/panic.go:914 +0x21f
github.com/dagger/dagger/core/schema.(*containerSchema).terminal(0x1d3a040?, {0x2299038, 0xc00330eea0}, {0xc005579280, 0xc00305f340, {0x0, 0x1, 0xc0033daf60, 0xc00394bed8}, 0x0}, ...)
/app/core/schema/container.go:1366 +0xc9
github.com/dagger/dagger/dagql.NodeFunc[...].func1({0xc005579280, 0xc00305f340, {0x0, 0x1, 0xc0033daf60, 0xc00394bed8}, 0x0}, 0xc00330ef00)
/app/dagql/objects.go:355 +0x184
github.com/dagger/dagger/dagql.Class[...].Call(0x22c3500?, {0x2299038?, 0xc00330eea0?}, {0xc005579280, 0xc00305f340, {0x0, 0x1, 0xc0033daf60, 0xc00394bed8}, 0x0}, ...)
/app/dagql/objects.go:202 +0x15d
github.com/dagger/dagger/dagql.Instance[...].Select(0x22b3a20, {0x2299038, 0xc00330eea0}, {{0xc000cd2508, 0x8}, {0x319c680, 0x0, 0x0}, 0x0})
/app/dagql/objects.go:271 +0x2fe
github.com/dagger/dagger/dagql.(*Server).cachedSelect.func1({0x2299038?, 0xc00330eea0?})
/app/dagql/server.go:583 +0x49
github.com/dagger/dagger/tracing.AroundFunc.ProgrockAroundFunc.func1({0x2299038, 0xc00330ed80})
/app/tracing/graphql.go:102 +0x5c4
github.com/dagger/dagger/tracing.AroundFunc.SpanAroundFunc.func2({0x2299038, 0xc003e691a0})
/app/tracing/graphql.go:33 +0xa6
github.com/dagger/dagger/dagql.(*cacheMap[...]).GetOrInitializeOnHit(0x22bf680, {0x2299038, 0xc003e68ea0}, {0xc003775130, 0x47}, 0xc004ccb788, 0xc0031f9b08)
/app/dagql/cachemap.go:85 +0x272
github.com/dagger/dagger/dagql.(*cacheMap[...]).GetOrInitialize(0xc0031f9b48?, {0x2299038?, 0xc003e68ea0?}, {0xc003775130?, 0x10c0f25?}, 0x229c200?)
/app/dagql/cachemap.go:60 +0x45
github.com/dagger/dagger/dagql.(*Server).cachedSelect(0xc003e1a4b0, {0x2299038, 0xc004a82630}, {0x229c200, 0xc002c9ac40}, {{0xc000cd2508, 0x8}, {0x319c680, 0x0, 0x0}, ...})
/app/dagql/server.go:592 +0x203
github.com/dagger/dagger/dagql.(*Server).resolvePath(0x1052c6b?, {0x2299038, 0xc004a82630}, {0x229c200?, 0xc002c9ac40?}, {{0xc000cd2508, 0x8}, {{0xc000cd2508, 0x8}, {0x319c680, ...}, ...}, ...})
/app/dagql/server.go:651 +0x13e
github.com/dagger/dagger/dagql.(*Server).Resolve.func1()
/app/dagql/server.go:405 +0x7f
github.com/dagger/dagger/dagql.(*Server).Resolve.(*ErrorPool).Go.func3()
/go/pkg/mod/github.com/sourcegraph/[email protected]/pool/error_pool.go:30 +0x22
github.com/sourcegraph/conc/pool.(*Pool).worker(0xc001825858?)
/go/pkg/mod/github.com/sourcegraph/[email protected]/pool/pool.go:154 +0x6f
github.com/sourcegraph/conc/panics.(*Catcher).Try(0x445edc?, 0x6?)
/go/pkg/mod/github.com/sourcegraph/[email protected]/panics/panics.go:23 +0x48
github.com/sourcegraph/conc.(*WaitGroup).Go.func1()
/go/pkg/mod/github.com/sourcegraph/[email protected]/waitgroup.go:32 +0x56
created by github.com/sourcegraph/conc.(*WaitGroup).Go in goroutine 372437
/go/pkg/mod/github.com/sourcegraph/[email protected]/waitgroup.go:30 +0x73
```
I can hit this if I `terminal` a container that doesn't have default args, and hasn't called `withDefaultTerminalCmd`. | https://github.com/dagger/dagger/issues/6828 | https://github.com/dagger/dagger/pull/6838 | e5f0bc7389dc0ba454fa8247de023e4a92efb1c2 | 7b69661a44e419b03d94264b74c3e99d6e98cf0d | "2024-03-05T16:34:06Z" | go | "2024-03-06T14:03:34Z" | .changes/unreleased/Fixed-20240306-145052.yaml | |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,828 | Panic in `terminal` if no args set | Think this is a regression in v0.10.1 cc @TomChv
See https://github.com/dagger/dagger/pull/6805/files#r1513137070
```
goroutine 457496 [running]:
runtime/debug.Stack()
/usr/local/go/src/runtime/debug/stack.go:24 +0x5e
github.com/dagger/dagger/dagql.(*Server).resolvePath.func1()
/app/dagql/server.go:642 +0x74
panic({0x1bd65a0?, 0x3139130?})
/usr/local/go/src/runtime/panic.go:914 +0x21f
github.com/dagger/dagger/core/schema.(*containerSchema).terminal(0x1d3a040?, {0x2299038, 0xc00330eea0}, {0xc005579280, 0xc00305f340, {0x0, 0x1, 0xc0033daf60, 0xc00394bed8}, 0x0}, ...)
/app/core/schema/container.go:1366 +0xc9
github.com/dagger/dagger/dagql.NodeFunc[...].func1({0xc005579280, 0xc00305f340, {0x0, 0x1, 0xc0033daf60, 0xc00394bed8}, 0x0}, 0xc00330ef00)
/app/dagql/objects.go:355 +0x184
github.com/dagger/dagger/dagql.Class[...].Call(0x22c3500?, {0x2299038?, 0xc00330eea0?}, {0xc005579280, 0xc00305f340, {0x0, 0x1, 0xc0033daf60, 0xc00394bed8}, 0x0}, ...)
/app/dagql/objects.go:202 +0x15d
github.com/dagger/dagger/dagql.Instance[...].Select(0x22b3a20, {0x2299038, 0xc00330eea0}, {{0xc000cd2508, 0x8}, {0x319c680, 0x0, 0x0}, 0x0})
/app/dagql/objects.go:271 +0x2fe
github.com/dagger/dagger/dagql.(*Server).cachedSelect.func1({0x2299038?, 0xc00330eea0?})
/app/dagql/server.go:583 +0x49
github.com/dagger/dagger/tracing.AroundFunc.ProgrockAroundFunc.func1({0x2299038, 0xc00330ed80})
/app/tracing/graphql.go:102 +0x5c4
github.com/dagger/dagger/tracing.AroundFunc.SpanAroundFunc.func2({0x2299038, 0xc003e691a0})
/app/tracing/graphql.go:33 +0xa6
github.com/dagger/dagger/dagql.(*cacheMap[...]).GetOrInitializeOnHit(0x22bf680, {0x2299038, 0xc003e68ea0}, {0xc003775130, 0x47}, 0xc004ccb788, 0xc0031f9b08)
/app/dagql/cachemap.go:85 +0x272
github.com/dagger/dagger/dagql.(*cacheMap[...]).GetOrInitialize(0xc0031f9b48?, {0x2299038?, 0xc003e68ea0?}, {0xc003775130?, 0x10c0f25?}, 0x229c200?)
/app/dagql/cachemap.go:60 +0x45
github.com/dagger/dagger/dagql.(*Server).cachedSelect(0xc003e1a4b0, {0x2299038, 0xc004a82630}, {0x229c200, 0xc002c9ac40}, {{0xc000cd2508, 0x8}, {0x319c680, 0x0, 0x0}, ...})
/app/dagql/server.go:592 +0x203
github.com/dagger/dagger/dagql.(*Server).resolvePath(0x1052c6b?, {0x2299038, 0xc004a82630}, {0x229c200?, 0xc002c9ac40?}, {{0xc000cd2508, 0x8}, {{0xc000cd2508, 0x8}, {0x319c680, ...}, ...}, ...})
/app/dagql/server.go:651 +0x13e
github.com/dagger/dagger/dagql.(*Server).Resolve.func1()
/app/dagql/server.go:405 +0x7f
github.com/dagger/dagger/dagql.(*Server).Resolve.(*ErrorPool).Go.func3()
/go/pkg/mod/github.com/sourcegraph/[email protected]/pool/error_pool.go:30 +0x22
github.com/sourcegraph/conc/pool.(*Pool).worker(0xc001825858?)
/go/pkg/mod/github.com/sourcegraph/[email protected]/pool/pool.go:154 +0x6f
github.com/sourcegraph/conc/panics.(*Catcher).Try(0x445edc?, 0x6?)
/go/pkg/mod/github.com/sourcegraph/[email protected]/panics/panics.go:23 +0x48
github.com/sourcegraph/conc.(*WaitGroup).Go.func1()
/go/pkg/mod/github.com/sourcegraph/[email protected]/waitgroup.go:32 +0x56
created by github.com/sourcegraph/conc.(*WaitGroup).Go in goroutine 372437
/go/pkg/mod/github.com/sourcegraph/[email protected]/waitgroup.go:30 +0x73
```
I can hit this if I `terminal` a container that doesn't have default args, and hasn't called `withDefaultTerminalCmd`. | https://github.com/dagger/dagger/issues/6828 | https://github.com/dagger/dagger/pull/6838 | e5f0bc7389dc0ba454fa8247de023e4a92efb1c2 | 7b69661a44e419b03d94264b74c3e99d6e98cf0d | "2024-03-05T16:34:06Z" | go | "2024-03-06T14:03:34Z" | core/container.go | package core
import (
"context"
"encoding/json"
"fmt"
"io/fs"
"os"
"path"
"path/filepath"
"sort"
"strconv"
"strings"
"sync"
"github.com/containerd/containerd/content"
"github.com/containerd/containerd/images"
"github.com/containerd/containerd/pkg/transfer/archive"
"github.com/containerd/containerd/platforms"
"github.com/vektah/gqlparser/v2/ast"
"github.com/dagger/dagger/dagql"
"github.com/dagger/dagger/dagql/idproto"
"github.com/dagger/dagger/engine"
"github.com/docker/distribution/reference"
"github.com/moby/buildkit/client/llb"
"github.com/moby/buildkit/exporter/containerimage/exptypes"
"github.com/moby/buildkit/frontend/dockerui"
bkgw "github.com/moby/buildkit/frontend/gateway/client"
"github.com/moby/buildkit/identity"
"github.com/moby/buildkit/solver/pb"
"github.com/moby/buildkit/util/leaseutil"
"github.com/opencontainers/go-digest"
specs "github.com/opencontainers/image-spec/specs-go/v1"
"github.com/pkg/errors"
"github.com/vito/progrock"
"github.com/dagger/dagger/core/pipeline"
"github.com/dagger/dagger/engine/buildkit"
)
var ErrContainerNoExec = errors.New("no command has been executed")
type DefaultTerminalCmdOpts struct {
Args []string
// Provide dagger access to the executed command
// Do not use this option unless you trust the command being executed.
// The command being executed WILL BE GRANTED FULL ACCESS TO YOUR HOST FILESYSTEM
ExperimentalPrivilegedNesting bool `default:"false"`
// Grant the process all root capabilities
InsecureRootCapabilities bool `default:"false"`
}
// Container is a content-addressed container.
type Container struct {
Query *Query
// The container's root filesystem.
FS *pb.Definition `json:"fs"`
// Image configuration (env, workdir, etc)
Config specs.ImageConfig `json:"cfg"`
// List of GPU devices that will be exposed to the container
EnabledGPUs []string `json:"enabledGPUs,omitempty"`
// Mount points configured for the container.
Mounts ContainerMounts `json:"mounts,omitempty"`
// Meta is the /dagger filesystem. It will be null if nothing has run yet.
Meta *pb.Definition `json:"meta,omitempty"`
// The platform of the container's rootfs.
Platform Platform `json:"platform,omitempty"`
// Secrets to expose to the container.
Secrets []ContainerSecret `json:"secret_env,omitempty"`
// Sockets to expose to the container.
Sockets []ContainerSocket `json:"sockets,omitempty"`
// Image reference
ImageRef string `json:"image_ref,omitempty"`
// Ports to expose from the container.
Ports []Port `json:"ports,omitempty"`
// Services to start before running the container.
Services ServiceBindings `json:"services,omitempty"`
// Focused indicates whether subsequent operations will be
// focused, i.e. shown more prominently in the UI.
Focused bool `json:"focused"`
// The args to invoke when using the terminal api on this container.
DefaultTerminalCmd *DefaultTerminalCmdOpts `json:"defaultTerminalCmd,omitempty"`
}
func (*Container) Type() *ast.Type {
return &ast.Type{
NamedType: "Container",
NonNull: true,
}
}
func (*Container) TypeDescription() string {
return "An OCI-compatible container, also known as a Docker container."
}
var _ HasPBDefinitions = (*Container)(nil)
func (container *Container) PBDefinitions(ctx context.Context) ([]*pb.Definition, error) {
var defs []*pb.Definition
if container.FS != nil {
defs = append(defs, container.FS)
}
for _, mnt := range container.Mounts {
if mnt.Source != nil {
defs = append(defs, mnt.Source)
}
}
for _, bnd := range container.Services {
ctr := bnd.Service.Container
if ctr == nil {
continue
}
ctrDefs, err := ctr.PBDefinitions(ctx)
if err != nil {
return nil, err
}
defs = append(defs, ctrDefs...)
}
return defs, nil
}
func NewContainer(root *Query, platform Platform) (*Container, error) {
if root == nil {
panic("query must be non-nil")
}
return &Container{
Query: root,
Platform: platform,
}, nil
}
// Clone returns a deep copy of the container suitable for modifying in a
// WithXXX method.
func (container *Container) Clone() *Container {
cp := *container
cp.Config.ExposedPorts = cloneMap(cp.Config.ExposedPorts)
cp.Config.Env = cloneSlice(cp.Config.Env)
cp.Config.Entrypoint = cloneSlice(cp.Config.Entrypoint)
cp.Config.Cmd = cloneSlice(cp.Config.Cmd)
cp.Config.Volumes = cloneMap(cp.Config.Volumes)
cp.Config.Labels = cloneMap(cp.Config.Labels)
cp.Mounts = cloneSlice(cp.Mounts)
cp.Secrets = cloneSlice(cp.Secrets)
cp.Sockets = cloneSlice(cp.Sockets)
cp.Ports = cloneSlice(cp.Ports)
cp.Services = cloneSlice(cp.Services)
return &cp
}
var _ pipeline.Pipelineable = (*Container)(nil)
// PipelinePath returns the container's pipeline path.
func (container *Container) PipelinePath() pipeline.Path {
return container.Query.Pipeline
}
// Ownership contains a UID/GID pair resolved from a user/group name or ID pair
// provided via the API. It primarily exists to distinguish an unspecified
// ownership from UID/GID 0 (root) ownership.
type Ownership struct {
UID int `json:"uid"`
GID int `json:"gid"`
}
func (owner Ownership) Opt() llb.ChownOption {
return llb.WithUIDGID(owner.UID, owner.GID)
}
// ContainerSecret configures a secret to expose, either as an environment
// variable or mounted to a file path.
type ContainerSecret struct {
Secret *Secret `json:"secret"`
EnvName string `json:"env,omitempty"`
MountPath string `json:"path,omitempty"`
Owner *Ownership `json:"owner,omitempty"`
Mode fs.FileMode `json:"mode,omitempty"`
}
// ContainerSocket configures a socket to expose, currently as a Unix socket,
// but potentially as a TCP or UDP address in the future.
type ContainerSocket struct {
Source *Socket `json:"socket"`
ContainerPath string `json:"container_path,omitempty"`
Owner *Ownership `json:"owner,omitempty"`
}
// FSState returns the container's root filesystem mount state. If there is
// none (as with an empty container ID), it returns scratch.
func (container *Container) FSState() (llb.State, error) {
if container.FS == nil {
return llb.Scratch(), nil
}
return defToState(container.FS)
}
// MetaState returns the container's metadata mount state. If the container has
// yet to run, it returns nil.
func (container *Container) MetaState() (*llb.State, error) {
if container.Meta == nil {
return nil, nil
}
metaSt, err := defToState(container.Meta)
if err != nil {
return nil, err
}
return &metaSt, nil
}
// ContainerMount is a mount point configured in a container.
type ContainerMount struct {
// The source of the mount.
Source *pb.Definition `json:"source,omitempty"`
// A path beneath the source to scope the mount to.
SourcePath string `json:"source_path,omitempty"`
// The path of the mount within the container.
Target string `json:"target"`
// Persist changes to the mount under this cache ID.
CacheVolumeID string `json:"cache_volume_id,omitempty"`
// How to share the cache across concurrent runs.
CacheSharingMode CacheSharingMode `json:"cache_sharing,omitempty"`
// Configure the mount as a tmpfs.
Tmpfs bool `json:"tmpfs,omitempty"`
// Configure the mount as read-only.
Readonly bool `json:"readonly,omitempty"`
}
// SourceState returns the state of the source of the mount.
func (mnt ContainerMount) SourceState() (llb.State, error) {
if mnt.Source == nil {
return llb.Scratch(), nil
}
return defToState(mnt.Source)
}
type ContainerMounts []ContainerMount
func (mnts ContainerMounts) With(newMnt ContainerMount) ContainerMounts {
mntsCp := make(ContainerMounts, 0, len(mnts))
// NB: this / might need to change on Windows, but I'm not even sure how
// mounts work on Windows, so...
parent := newMnt.Target + "/"
for _, mnt := range mnts {
if mnt.Target == newMnt.Target || strings.HasPrefix(mnt.Target, parent) {
continue
}
mntsCp = append(mntsCp, mnt)
}
mntsCp = append(mntsCp, newMnt)
return mntsCp
}
func (container *Container) From(ctx context.Context, addr string) (*Container, error) {
bk := container.Query.Buildkit
container = container.Clone()
platform := container.Platform
// `From` creates 2 vertices: fetching the image config and actually pulling the image.
// We create a sub-pipeline to encapsulate both.
ctx, subRecorder := progrock.WithGroup(ctx, fmt.Sprintf("from %s", addr), progrock.Weak())
refName, err := reference.ParseNormalizedNamed(addr)
if err != nil {
return nil, err
}
ref := reference.TagNameOnly(refName).String()
_, digest, cfgBytes, err := bk.ResolveImageConfig(ctx, ref, llb.ResolveImageConfigOpt{
Platform: ptr(platform.Spec()),
ResolveMode: llb.ResolveModeDefault.String(),
})
if err != nil {
return nil, err
}
digested, err := reference.WithDigest(refName, digest)
if err != nil {
return nil, err
}
var imgSpec specs.Image
if err := json.Unmarshal(cfgBytes, &imgSpec); err != nil {
return nil, err
}
fsSt := llb.Image(
digested.String(),
llb.WithCustomNamef("pull %s", ref),
)
def, err := fsSt.Marshal(ctx, llb.Platform(platform.Spec()))
if err != nil {
return nil, err
}
container.FS = def.ToPB()
// associate vertexes to the 'from' sub-pipeline
buildkit.RecordVertexes(subRecorder, container.FS)
container.Config = mergeImageConfig(container.Config, imgSpec.Config)
container.ImageRef = digested.String()
return container, nil
}
const defaultDockerfileName = "Dockerfile"
func (container *Container) Build(
ctx context.Context,
contextDir *Directory,
dockerfile string,
buildArgs []BuildArg,
target string,
secrets []*Secret,
) (*Container, error) {
container = container.Clone()
container.Services.Merge(contextDir.Services)
for _, secret := range secrets {
container.Secrets = append(container.Secrets, ContainerSecret{
Secret: secret,
MountPath: fmt.Sprintf("/run/secrets/%s", secret.Name),
})
}
// set image ref to empty string
container.ImageRef = ""
svcs := container.Query.Services
bk := container.Query.Buildkit
// add a weak group for the docker build vertices
ctx, subRecorder := progrock.WithGroup(ctx, "docker build", progrock.Weak())
detach, _, err := svcs.StartBindings(ctx, container.Services)
if err != nil {
return nil, err
}
defer detach()
platform := container.Platform
opts := map[string]string{
"platform": platform.Format(),
"contextsubdir": contextDir.Dir,
}
if dockerfile != "" {
opts["filename"] = path.Join(contextDir.Dir, dockerfile)
} else {
opts["filename"] = path.Join(contextDir.Dir, defaultDockerfileName)
}
if target != "" {
opts["target"] = target
}
for _, buildArg := range buildArgs {
opts["build-arg:"+buildArg.Name] = buildArg.Value
}
inputs := map[string]*pb.Definition{
dockerui.DefaultLocalNameContext: contextDir.LLB,
dockerui.DefaultLocalNameDockerfile: contextDir.LLB,
}
// FIXME: ew, this is a terrible way to pass this around
//nolint:staticcheck
solveCtx := context.WithValue(ctx, "secret-translator", func(name string) (string, error) {
return GetLocalSecretAccessor(ctx, container.Query, name)
})
res, err := bk.Solve(solveCtx, bkgw.SolveRequest{
Frontend: "dockerfile.v0",
FrontendOpt: opts,
FrontendInputs: inputs,
})
if err != nil {
return nil, err
}
bkref, err := res.SingleRef()
if err != nil {
return nil, err
}
var st llb.State
if bkref == nil {
st = llb.Scratch()
} else {
st, err = bkref.ToState()
if err != nil {
return nil, err
}
}
def, err := st.Marshal(ctx, llb.Platform(platform.Spec()))
if err != nil {
return nil, err
}
// associate vertexes to the 'docker build' sub-pipeline
buildkit.RecordVertexes(subRecorder, def.ToPB())
container.FS = def.ToPB()
container.FS.Source = nil
cfgBytes, found := res.Metadata[exptypes.ExporterImageConfigKey]
if found {
var imgSpec specs.Image
if err := json.Unmarshal(cfgBytes, &imgSpec); err != nil {
return nil, err
}
container.Config = mergeImageConfig(container.Config, imgSpec.Config)
}
return container, nil
}
func (container *Container) RootFS(ctx context.Context) (*Directory, error) {
return &Directory{
Query: container.Query,
LLB: container.FS,
Dir: "/",
Platform: container.Platform,
Services: container.Services,
}, nil
}
func (container *Container) WithRootFS(ctx context.Context, dir *Directory) (*Container, error) {
container = container.Clone()
dirSt, err := dir.StateWithSourcePath()
if err != nil {
return nil, err
}
def, err := dirSt.Marshal(ctx, llb.Platform(dir.Platform.Spec()))
if err != nil {
return nil, err
}
container.FS = def.ToPB()
container.Services.Merge(dir.Services)
// set image ref to empty string
container.ImageRef = ""
return container, nil
}
func (container *Container) WithDirectory(ctx context.Context, subdir string, src *Directory, filter CopyFilter, owner string) (*Container, error) {
container = container.Clone()
return container.writeToPath(ctx, subdir, func(dir *Directory) (*Directory, error) {
ownership, err := container.ownership(ctx, owner)
if err != nil {
return nil, err
}
return dir.WithDirectory(ctx, ".", src, filter, ownership)
})
}
func (container *Container) WithFile(ctx context.Context, destPath string, src *File, permissions *int, owner string) (*Container, error) {
container = container.Clone()
return container.writeToPath(ctx, path.Dir(destPath), func(dir *Directory) (*Directory, error) {
ownership, err := container.ownership(ctx, owner)
if err != nil {
return nil, err
}
return dir.WithFile(ctx, path.Base(destPath), src, permissions, ownership)
})
}
func (container *Container) WithFiles(ctx context.Context, destDir string, src []*File, permissions *int, owner string) (*Container, error) {
container = container.Clone()
return container.writeToPath(ctx, path.Dir(destDir), func(dir *Directory) (*Directory, error) {
ownership, err := container.ownership(ctx, owner)
if err != nil {
return nil, err
}
return dir.WithFiles(ctx, destDir, src, permissions, ownership)
})
}
func (container *Container) WithNewFile(ctx context.Context, dest string, content []byte, permissions fs.FileMode, owner string) (*Container, error) {
container = container.Clone()
dir, file := filepath.Split(dest)
return container.writeToPath(ctx, dir, func(dir *Directory) (*Directory, error) {
ownership, err := container.ownership(ctx, owner)
if err != nil {
return nil, err
}
return dir.WithNewFile(ctx, file, content, permissions, ownership)
})
}
func (container *Container) WithMountedDirectory(ctx context.Context, target string, dir *Directory, owner string, readonly bool) (*Container, error) {
container = container.Clone()
return container.withMounted(ctx, target, dir.LLB, dir.Dir, dir.Services, owner, readonly)
}
func (container *Container) WithMountedFile(ctx context.Context, target string, file *File, owner string, readonly bool) (*Container, error) {
container = container.Clone()
return container.withMounted(ctx, target, file.LLB, file.File, file.Services, owner, readonly)
}
var SeenCacheKeys = new(sync.Map)
func (container *Container) WithMountedCache(ctx context.Context, target string, cache *CacheVolume, source *Directory, sharingMode CacheSharingMode, owner string) (*Container, error) {
container = container.Clone()
target = absPath(container.Config.WorkingDir, target)
if sharingMode == "" {
sharingMode = CacheSharingModeShared
}
mount := ContainerMount{
Target: target,
CacheVolumeID: cache.Sum(),
CacheSharingMode: sharingMode,
}
if source != nil {
mount.Source = source.LLB
mount.SourcePath = source.Dir
}
if owner != "" {
var err error
mount.Source, mount.SourcePath, err = container.chown(
ctx,
mount.Source,
mount.SourcePath,
owner,
llb.Platform(container.Platform.Spec()),
)
if err != nil {
return nil, err
}
}
container.Mounts = container.Mounts.With(mount)
// set image ref to empty string
container.ImageRef = ""
SeenCacheKeys.Store(cache.Keys[0], struct{}{})
return container, nil
}
func (container *Container) WithMountedTemp(ctx context.Context, target string) (*Container, error) {
container = container.Clone()
target = absPath(container.Config.WorkingDir, target)
container.Mounts = container.Mounts.With(ContainerMount{
Target: target,
Tmpfs: true,
})
// set image ref to empty string
container.ImageRef = ""
return container, nil
}
func (container *Container) WithMountedSecret(ctx context.Context, target string, source *Secret, owner string, mode fs.FileMode) (*Container, error) {
container = container.Clone()
target = absPath(container.Config.WorkingDir, target)
ownership, err := container.ownership(ctx, owner)
if err != nil {
return nil, err
}
container.Secrets = append(container.Secrets, ContainerSecret{
Secret: source,
MountPath: target,
Owner: ownership,
Mode: mode,
})
// set image ref to empty string
container.ImageRef = ""
return container, nil
}
func (container *Container) WithoutMount(ctx context.Context, target string) (*Container, error) {
container = container.Clone()
target = absPath(container.Config.WorkingDir, target)
var found bool
var foundIdx int
for i := len(container.Mounts) - 1; i >= 0; i-- {
if container.Mounts[i].Target == target {
found = true
foundIdx = i
break
}
}
if found {
container.Mounts = append(container.Mounts[:foundIdx], container.Mounts[foundIdx+1:]...)
}
// set image ref to empty string
container.ImageRef = ""
return container, nil
}
func (container *Container) MountTargets(ctx context.Context) ([]string, error) {
mounts := []string{}
for _, mnt := range container.Mounts {
mounts = append(mounts, mnt.Target)
}
return mounts, nil
}
func (container *Container) WithUnixSocket(ctx context.Context, target string, source *Socket, owner string) (*Container, error) {
container = container.Clone()
target = absPath(container.Config.WorkingDir, target)
ownership, err := container.ownership(ctx, owner)
if err != nil {
return nil, err
}
newSocket := ContainerSocket{
Source: source,
ContainerPath: target,
Owner: ownership,
}
var replaced bool
for i, sock := range container.Sockets {
if sock.ContainerPath == target {
container.Sockets[i] = newSocket
replaced = true
break
}
}
if !replaced {
container.Sockets = append(container.Sockets, newSocket)
}
// set image ref to empty string
container.ImageRef = ""
return container, nil
}
func (container *Container) WithoutUnixSocket(ctx context.Context, target string) (*Container, error) {
container = container.Clone()
target = absPath(container.Config.WorkingDir, target)
for i, sock := range container.Sockets {
if sock.ContainerPath == target {
container.Sockets = append(container.Sockets[:i], container.Sockets[i+1:]...)
break
}
}
// set image ref to empty string
container.ImageRef = ""
return container, nil
}
func (container *Container) WithSecretVariable(ctx context.Context, name string, secret *Secret) (*Container, error) {
container = container.Clone()
container.Secrets = append(container.Secrets, ContainerSecret{
Secret: secret,
EnvName: name,
})
// set image ref to empty string
container.ImageRef = ""
return container, nil
}
func (container *Container) Directory(ctx context.Context, dirPath string) (*Directory, error) {
dir, _, err := locatePath(ctx, container, dirPath, NewDirectory)
if err != nil {
return nil, err
}
svcs := container.Query.Services
bk := container.Query.Buildkit
// check that the directory actually exists so the user gets an error earlier
// rather than when the dir is used
info, err := dir.Stat(ctx, bk, svcs, ".")
if err != nil {
return nil, err
}
if !info.IsDir() {
return nil, fmt.Errorf("path %s is a file, not a directory", dirPath)
}
return dir, nil
}
func (container *Container) File(ctx context.Context, filePath string) (*File, error) {
file, _, err := locatePath(ctx, container, filePath, NewFile)
if err != nil {
return nil, err
}
// check that the file actually exists so the user gets an error earlier
// rather than when the file is used
info, err := file.Stat(ctx)
if err != nil {
return nil, err
}
if info.IsDir() {
return nil, fmt.Errorf("path %s is a directory, not a file", filePath)
}
return file, nil
}
func locatePath[T *File | *Directory](
ctx context.Context,
container *Container,
containerPath string,
init func(*Query, *pb.Definition, string, Platform, ServiceBindings) T,
) (T, *ContainerMount, error) {
containerPath = absPath(container.Config.WorkingDir, containerPath)
// NB(vito): iterate in reverse order so we'll find deeper mounts first
for i := len(container.Mounts) - 1; i >= 0; i-- {
mnt := container.Mounts[i]
if containerPath == mnt.Target || strings.HasPrefix(containerPath, mnt.Target+"/") {
if mnt.Tmpfs {
return nil, nil, fmt.Errorf("%s: cannot retrieve path from tmpfs", containerPath)
}
if mnt.CacheVolumeID != "" {
return nil, nil, fmt.Errorf("%s: cannot retrieve path from cache", containerPath)
}
sub := mnt.SourcePath
if containerPath != mnt.Target {
// make relative portion relative to the source path
dirSub := strings.TrimPrefix(containerPath, mnt.Target+"/")
if dirSub != "" {
sub = path.Join(sub, dirSub)
}
}
return init(
container.Query,
mnt.Source,
sub,
container.Platform,
container.Services,
), &mnt, nil
}
}
// Not found in a mount
return init(
container.Query,
container.FS,
containerPath,
container.Platform,
container.Services,
), nil, nil
}
func (container *Container) withMounted(
ctx context.Context,
target string,
srcDef *pb.Definition,
srcPath string,
svcs ServiceBindings,
owner string,
readonly bool,
) (*Container, error) {
target = absPath(container.Config.WorkingDir, target)
var err error
if owner != "" {
srcDef, srcPath, err = container.chown(ctx, srcDef, srcPath, owner, llb.Platform(container.Platform.Spec()))
if err != nil {
return nil, err
}
}
container.Mounts = container.Mounts.With(ContainerMount{
Source: srcDef,
SourcePath: srcPath,
Target: target,
Readonly: readonly,
})
container.Services.Merge(svcs)
// set image ref to empty string
container.ImageRef = ""
return container, nil
}
func (container *Container) chown(
ctx context.Context,
srcDef *pb.Definition,
srcPath string,
owner string,
opts ...llb.ConstraintsOpt,
) (*pb.Definition, string, error) {
ownership, err := container.ownership(ctx, owner)
if err != nil {
return nil, "", err
}
if ownership == nil {
return srcDef, srcPath, nil
}
var srcSt llb.State
if srcDef == nil {
// e.g. empty cache mount
srcSt = llb.Scratch().File(
llb.Mkdir("/chown", 0o755, ownership.Opt()),
)
srcPath = "/chown"
} else {
srcSt, err = defToState(srcDef)
if err != nil {
return nil, "", err
}
def, err := srcSt.Marshal(ctx, opts...)
if err != nil {
return nil, "", err
}
ref, err := bkRef(ctx, container.Query.Buildkit, def.ToPB())
if err != nil {
return nil, "", err
}
stat, err := ref.StatFile(ctx, bkgw.StatRequest{
Path: srcPath,
})
if err != nil {
return nil, "", err
}
if stat.IsDir() {
chowned := "/chown"
// NB(vito): need to create intermediate directory with correct ownership
// to handle the directory case, otherwise the mount will be owned by
// root
srcSt = llb.Scratch().File(
llb.Mkdir(chowned, os.FileMode(stat.Mode), ownership.Opt()).
Copy(srcSt, srcPath, chowned, &llb.CopyInfo{
CopyDirContentsOnly: true,
}, ownership.Opt()),
)
srcPath = chowned
} else {
srcSt = llb.Scratch().File(
llb.Copy(srcSt, srcPath, ".", ownership.Opt()),
)
srcPath = filepath.Base(srcPath)
}
}
def, err := srcSt.Marshal(ctx, opts...)
if err != nil {
return nil, "", err
}
return def.ToPB(), srcPath, nil
}
func (container *Container) writeToPath(ctx context.Context, subdir string, fn func(dir *Directory) (*Directory, error)) (*Container, error) {
dir, mount, err := locatePath(ctx, container, subdir, NewDirectory)
if err != nil {
return nil, err
}
dir, err = fn(dir)
if err != nil {
return nil, err
}
// If not in a mount, replace rootfs
if mount == nil {
root, err := dir.Root()
if err != nil {
return nil, err
}
return container.WithRootFS(ctx, root)
}
return container.withMounted(ctx, mount.Target, dir.LLB, mount.SourcePath, nil, "", false)
}
func (container *Container) ImageConfig(ctx context.Context) (specs.ImageConfig, error) {
return container.Config, nil
}
func (container *Container) UpdateImageConfig(ctx context.Context, updateFn func(specs.ImageConfig) specs.ImageConfig) (*Container, error) {
container = container.Clone()
container.Config = updateFn(container.Config)
return container, nil
}
func (container *Container) WithPipeline(ctx context.Context, name, description string, labels []pipeline.Label) (*Container, error) {
container = container.Clone()
container.Query = container.Query.WithPipeline(name, description, labels)
return container, nil
}
type ContainerGPUOpts struct {
Devices []string
}
func (container *Container) WithGPU(ctx context.Context, gpuOpts ContainerGPUOpts) (*Container, error) {
container = container.Clone()
container.EnabledGPUs = gpuOpts.Devices
return container, nil
}
func (container *Container) WithExec(ctx context.Context, opts ContainerExecOpts) (*Container, error) { //nolint:gocyclo
container = container.Clone()
cfg := container.Config
mounts := container.Mounts
platform := container.Platform
if platform.OS == "" {
platform = container.Query.Platform
}
args, err := container.command(opts)
if err != nil {
return nil, err
}
var namef string
if container.Focused {
namef = buildkit.FocusPrefix + "exec %s"
} else {
namef = "exec %s"
}
runOpts := []llb.RunOption{
llb.Args(args),
llb.WithCustomNamef(namef, strings.Join(args, " ")),
}
// this allows executed containers to communicate back to this API
if opts.ExperimentalPrivilegedNesting {
// include the engine version so that these execs get invalidated if the engine/API change
runOpts = append(runOpts, llb.AddEnv("_DAGGER_ENABLE_NESTING", engine.Version))
}
if opts.ModuleCallerDigest != "" {
runOpts = append(runOpts, llb.AddEnv("_DAGGER_MODULE_CALLER_DIGEST", opts.ModuleCallerDigest.String()))
}
if opts.NestedInSameSession {
runOpts = append(runOpts, llb.AddEnv("_DAGGER_ENABLE_NESTING_IN_SAME_SESSION", ""))
}
metaSt, metaSourcePath := metaMount(opts.Stdin)
// create /dagger mount point for the shim to write to
runOpts = append(runOpts,
llb.AddMount(buildkit.MetaMountDestPath, metaSt, llb.SourcePath(metaSourcePath)))
if opts.RedirectStdout != "" {
runOpts = append(runOpts, llb.AddEnv("_DAGGER_REDIRECT_STDOUT", opts.RedirectStdout))
}
if opts.RedirectStderr != "" {
runOpts = append(runOpts, llb.AddEnv("_DAGGER_REDIRECT_STDERR", opts.RedirectStderr))
}
for _, bnd := range container.Services {
for _, alias := range bnd.Aliases {
runOpts = append(runOpts,
llb.AddEnv("_DAGGER_HOSTNAME_ALIAS_"+alias, bnd.Hostname))
}
}
if cfg.User != "" {
runOpts = append(runOpts, llb.User(cfg.User))
}
if cfg.WorkingDir != "" {
runOpts = append(runOpts, llb.Dir(cfg.WorkingDir))
}
for _, env := range cfg.Env {
name, val, ok := strings.Cut(env, "=")
if !ok {
// it's OK to not be OK
// we'll just set an empty env
_ = ok
}
// don't pass these through to the container when manually set, they are internal only
if name == "_DAGGER_ENABLE_NESTING" && !opts.ExperimentalPrivilegedNesting {
continue
}
if name == "_DAGGER_MODULE_CALLER_DIGEST" && opts.ModuleCallerDigest == "" {
continue
}
if name == "_DAGGER_ENABLE_NESTING_IN_SAME_SESSION" && !opts.NestedInSameSession {
continue
}
runOpts = append(runOpts, llb.AddEnv(name, val))
}
// if GPU parameters are set for this container pass them over:
if len(container.EnabledGPUs) > 0 {
if gpuSupportEnabled := os.Getenv("_EXPERIMENTAL_DAGGER_GPU_SUPPORT"); gpuSupportEnabled == "" {
return nil, fmt.Errorf("GPU support is not enabled, set _EXPERIMENTAL_DAGGER_GPU_SUPPORT")
}
runOpts = append(runOpts, llb.AddEnv("_EXPERIMENTAL_DAGGER_GPU_PARAMS", strings.Join(container.EnabledGPUs, ",")))
}
secretsToScrub := SecretToScrubInfo{}
for i, secret := range container.Secrets {
secretOpts := []llb.SecretOption{llb.SecretID(secret.Secret.Accessor)}
var secretDest string
switch {
case secret.EnvName != "":
secretDest = secret.EnvName
secretOpts = append(secretOpts, llb.SecretAsEnv(true))
secretsToScrub.Envs = append(secretsToScrub.Envs, secret.EnvName)
case secret.MountPath != "":
secretDest = secret.MountPath
secretsToScrub.Files = append(secretsToScrub.Files, secret.MountPath)
if secret.Owner != nil {
secretOpts = append(secretOpts, llb.SecretFileOpt(
secret.Owner.UID,
secret.Owner.GID,
int(secret.Mode),
))
}
default:
return nil, fmt.Errorf("malformed secret config at index %d", i)
}
runOpts = append(runOpts, llb.AddSecret(secretDest, secretOpts...))
}
if len(secretsToScrub.Envs) != 0 || len(secretsToScrub.Files) != 0 {
// we sort to avoid non-deterministic order that would break caching
sort.Strings(secretsToScrub.Envs)
sort.Strings(secretsToScrub.Files)
secretsToScrubJSON, err := json.Marshal(secretsToScrub)
if err != nil {
return nil, fmt.Errorf("scrub secrets json: %w", err)
}
runOpts = append(runOpts, llb.AddEnv("_DAGGER_SCRUB_SECRETS", string(secretsToScrubJSON)))
}
for _, ctrSocket := range container.Sockets {
if ctrSocket.ContainerPath == "" {
return nil, fmt.Errorf("unsupported socket: only unix paths are implemented")
}
socketOpts := []llb.SSHOption{
llb.SSHID(ctrSocket.Source.SSHID()),
llb.SSHSocketTarget(ctrSocket.ContainerPath),
}
if ctrSocket.Owner != nil {
socketOpts = append(socketOpts,
llb.SSHSocketOpt(
ctrSocket.ContainerPath,
ctrSocket.Owner.UID,
ctrSocket.Owner.GID,
0o600, // preserve default
))
}
runOpts = append(runOpts, llb.AddSSHSocket(socketOpts...))
}
for _, mnt := range mounts {
srcSt, err := mnt.SourceState()
if err != nil {
return nil, fmt.Errorf("mount %s: %w", mnt.Target, err)
}
mountOpts := []llb.MountOption{}
if mnt.SourcePath != "" {
mountOpts = append(mountOpts, llb.SourcePath(mnt.SourcePath))
}
if mnt.CacheVolumeID != "" {
var sharingMode llb.CacheMountSharingMode
switch mnt.CacheSharingMode {
case CacheSharingModeShared:
sharingMode = llb.CacheMountShared
case CacheSharingModePrivate:
sharingMode = llb.CacheMountPrivate
case CacheSharingModeLocked:
sharingMode = llb.CacheMountLocked
default:
return nil, errors.Errorf("invalid cache mount sharing mode %q", mnt.CacheSharingMode)
}
mountOpts = append(mountOpts, llb.AsPersistentCacheDir(mnt.CacheVolumeID, sharingMode))
}
if mnt.Tmpfs {
mountOpts = append(mountOpts, llb.Tmpfs())
}
if mnt.Readonly {
mountOpts = append(mountOpts, llb.Readonly)
}
runOpts = append(runOpts, llb.AddMount(mnt.Target, srcSt, mountOpts...))
}
if opts.InsecureRootCapabilities {
runOpts = append(runOpts, llb.Security(llb.SecurityModeInsecure))
}
fsSt, err := container.FSState()
if err != nil {
return nil, fmt.Errorf("fs state: %w", err)
}
execSt := fsSt.Run(runOpts...)
execDef, err := execSt.Root().Marshal(ctx, llb.Platform(platform.Spec()))
if err != nil {
return nil, fmt.Errorf("marshal root: %w", err)
}
container.FS = execDef.ToPB()
metaDef, err := execSt.GetMount(buildkit.MetaMountDestPath).Marshal(ctx, llb.Platform(platform.Spec()))
if err != nil {
return nil, fmt.Errorf("get meta mount: %w", err)
}
container.Meta = metaDef.ToPB()
for i, mnt := range mounts {
if mnt.Tmpfs || mnt.CacheVolumeID != "" {
continue
}
mountSt := execSt.GetMount(mnt.Target)
// propagate any changes to regular mounts to subsequent containers
execMountDef, err := mountSt.Marshal(ctx, llb.Platform(platform.Spec()))
if err != nil {
return nil, fmt.Errorf("propagate %s: %w", mnt.Target, err)
}
mounts[i].Source = execMountDef.ToPB()
}
container.Mounts = mounts
// set image ref to empty string
container.ImageRef = ""
return container, nil
}
func (container Container) Evaluate(ctx context.Context) (*buildkit.Result, error) {
if container.FS == nil {
return nil, nil
}
root := container.Query
detach, _, err := root.Services.StartBindings(ctx, container.Services)
if err != nil {
return nil, err
}
defer detach()
st, err := container.FSState()
if err != nil {
return nil, err
}
def, err := st.Marshal(ctx, llb.Platform(container.Platform.Spec()))
if err != nil {
return nil, err
}
return root.Buildkit.Solve(ctx, bkgw.SolveRequest{
Evaluate: true,
Definition: def.ToPB(),
})
}
func (container *Container) MetaFileContents(ctx context.Context, filePath string) (string, error) {
if container.Meta == nil {
ctr, err := container.WithExec(ctx, ContainerExecOpts{})
if err != nil {
return "", err
}
return ctr.MetaFileContents(ctx, filePath)
}
file := NewFile(
container.Query,
container.Meta,
path.Join(buildkit.MetaSourcePath, filePath),
container.Platform,
container.Services,
)
content, err := file.Contents(ctx)
if err != nil {
return "", err
}
return string(content), nil
}
func (container *Container) Publish(
ctx context.Context,
ref string,
platformVariants []*Container,
forcedCompression ImageLayerCompression,
mediaTypes ImageMediaTypes,
) (string, error) {
if mediaTypes == "" {
// Modern registry implementations support oci types and docker daemons
// have been capable of pulling them since 2018:
// https://github.com/moby/moby/pull/37359
// So they are a safe default.
mediaTypes = OCIMediaTypes
}
inputByPlatform := map[string]buildkit.ContainerExport{}
services := ServiceBindings{}
for _, variant := range append([]*Container{container}, platformVariants...) {
if variant.FS == nil {
continue
}
st, err := variant.FSState()
if err != nil {
return "", err
}
def, err := st.Marshal(ctx, llb.Platform(variant.Platform.Spec()))
if err != nil {
return "", err
}
platformString := variant.Platform.Format()
if _, ok := inputByPlatform[platformString]; ok {
return "", fmt.Errorf("duplicate platform %q", platformString)
}
inputByPlatform[platformString] = buildkit.ContainerExport{
Definition: def.ToPB(),
Config: variant.Config,
}
services.Merge(variant.Services)
}
if len(inputByPlatform) == 0 {
// Could also just ignore and do nothing, airing on side of error until proven otherwise.
return "", errors.New("no containers to export")
}
opts := map[string]string{
string(exptypes.OptKeyName): ref,
string(exptypes.OptKeyPush): strconv.FormatBool(true),
string(exptypes.OptKeyOCITypes): strconv.FormatBool(mediaTypes == OCIMediaTypes),
}
if forcedCompression != "" {
opts[string(exptypes.OptKeyLayerCompression)] = strings.ToLower(string(forcedCompression))
opts[string(exptypes.OptKeyForceCompression)] = strconv.FormatBool(true)
}
svcs := container.Query.Services
bk := container.Query.Buildkit
detach, _, err := svcs.StartBindings(ctx, services)
if err != nil {
return "", err
}
defer detach()
resp, err := bk.PublishContainerImage(ctx, inputByPlatform, opts)
if err != nil {
return "", err
}
refName, err := reference.ParseNormalizedNamed(ref)
if err != nil {
return "", err
}
imageDigest, found := resp[exptypes.ExporterImageDigestKey]
if found {
dig, err := digest.Parse(imageDigest)
if err != nil {
return "", fmt.Errorf("parse digest: %w", err)
}
withDig, err := reference.WithDigest(refName, dig)
if err != nil {
return "", fmt.Errorf("with digest: %w", err)
}
return withDig.String(), nil
}
return ref, nil
}
func (container *Container) Export(
ctx context.Context,
dest string,
platformVariants []*Container,
forcedCompression ImageLayerCompression,
mediaTypes ImageMediaTypes,
) error {
svcs := container.Query.Services
bk := container.Query.Buildkit
if mediaTypes == "" {
// Modern registry implementations support oci types and docker daemons
// have been capable of pulling them since 2018:
// https://github.com/moby/moby/pull/37359
// So they are a safe default.
mediaTypes = OCIMediaTypes
}
inputByPlatform := map[string]buildkit.ContainerExport{}
services := ServiceBindings{}
for _, variant := range append([]*Container{container}, platformVariants...) {
if variant.FS == nil {
continue
}
st, err := variant.FSState()
if err != nil {
return err
}
def, err := st.Marshal(ctx, llb.Platform(variant.Platform.Spec()))
if err != nil {
return err
}
platformString := variant.Platform.Format()
if _, ok := inputByPlatform[platformString]; ok {
return fmt.Errorf("duplicate platform %q", platformString)
}
inputByPlatform[platformString] = buildkit.ContainerExport{
Definition: def.ToPB(),
Config: variant.Config,
}
services.Merge(variant.Services)
}
if len(inputByPlatform) == 0 {
// Could also just ignore and do nothing, airing on side of error until proven otherwise.
return errors.New("no containers to export")
}
opts := map[string]string{
"tar": strconv.FormatBool(true),
string(exptypes.OptKeyOCITypes): strconv.FormatBool(mediaTypes == OCIMediaTypes),
}
if forcedCompression != "" {
opts[string(exptypes.OptKeyLayerCompression)] = strings.ToLower(string(forcedCompression))
opts[string(exptypes.OptKeyForceCompression)] = strconv.FormatBool(true)
}
detach, _, err := svcs.StartBindings(ctx, services)
if err != nil {
return err
}
defer detach()
_, err = bk.ExportContainerImage(ctx, inputByPlatform, dest, opts)
return err
}
func (container *Container) AsTarball(
ctx context.Context,
platformVariants []*Container,
forcedCompression ImageLayerCompression,
mediaTypes ImageMediaTypes,
) (*File, error) {
bk := container.Query.Buildkit
svcs := container.Query.Services
engineHostPlatform := container.Query.Platform
if mediaTypes == "" {
mediaTypes = OCIMediaTypes
}
inputByPlatform := map[string]buildkit.ContainerExport{}
services := ServiceBindings{}
for _, variant := range append([]*Container{container}, platformVariants...) {
if variant.FS == nil {
continue
}
st, err := variant.FSState()
if err != nil {
return nil, err
}
def, err := st.Marshal(ctx, llb.Platform(variant.Platform.Spec()))
if err != nil {
return nil, err
}
platformString := platforms.Format(variant.Platform.Spec())
if _, ok := inputByPlatform[platformString]; ok {
return nil, fmt.Errorf("duplicate platform %q", platformString)
}
inputByPlatform[platformString] = buildkit.ContainerExport{
Definition: def.ToPB(),
Config: variant.Config,
}
services.Merge(variant.Services)
}
if len(inputByPlatform) == 0 {
return nil, errors.New("no containers to export")
}
opts := map[string]string{
"tar": strconv.FormatBool(true),
string(exptypes.OptKeyOCITypes): strconv.FormatBool(mediaTypes == OCIMediaTypes),
}
if forcedCompression != "" {
opts[string(exptypes.OptKeyLayerCompression)] = strings.ToLower(string(forcedCompression))
opts[string(exptypes.OptKeyForceCompression)] = strconv.FormatBool(true)
}
detach, _, err := svcs.StartBindings(ctx, services)
if err != nil {
return nil, err
}
defer detach()
fileName := identity.NewID() + ".tar"
pbDef, err := bk.ContainerImageToTarball(ctx, engineHostPlatform.Spec(), fileName, inputByPlatform, opts)
if err != nil {
return nil, fmt.Errorf("container image to tarball file conversion failed: %w", err)
}
return NewFile(container.Query, pbDef, fileName, engineHostPlatform, nil), nil
}
func (container *Container) Import(
ctx context.Context,
source *File,
tag string,
) (*Container, error) {
bk := container.Query.Buildkit
store := container.Query.OCIStore
lm := container.Query.LeaseManager
container = container.Clone()
var release func(context.Context) error
loadManifest := func(ctx context.Context) (*specs.Descriptor, error) {
src, err := source.Open(ctx)
if err != nil {
return nil, err
}
defer src.Close()
// override outer ctx with release ctx and set release
ctx, release, err = leaseutil.WithLease(ctx, lm, leaseutil.MakeTemporary)
if err != nil {
return nil, err
}
stream := archive.NewImageImportStream(src, "")
desc, err := stream.Import(ctx, store)
if err != nil {
return nil, fmt.Errorf("image archive import: %w", err)
}
return resolveIndex(ctx, store, desc, container.Platform.Spec(), tag)
}
manifestDesc, err := loadManifest(ctx)
if err != nil {
return nil, fmt.Errorf("recover: %w", err)
}
// NB: the repository portion of this ref doesn't actually matter, but it's
// pleasant to see something recognizable.
dummyRepo := "dagger/import"
st := llb.OCILayout(
fmt.Sprintf("%s@%s", dummyRepo, manifestDesc.Digest),
llb.OCIStore("", buildkit.OCIStoreName),
llb.Platform(container.Platform.Spec()),
)
execDef, err := st.Marshal(ctx, llb.Platform(container.Platform.Spec()))
if err != nil {
return nil, fmt.Errorf("marshal root: %w", err)
}
container.FS = execDef.ToPB()
if release != nil {
// eagerly evaluate the OCI reference so Buildkit sets up a long-term lease
_, err = bk.Solve(ctx, bkgw.SolveRequest{
Definition: container.FS,
Evaluate: true,
})
if err != nil {
return nil, fmt.Errorf("solve: %w", err)
}
if err := release(ctx); err != nil {
return nil, fmt.Errorf("release: %w", err)
}
}
manifestBlob, err := content.ReadBlob(ctx, store, *manifestDesc)
if err != nil {
return nil, fmt.Errorf("image archive read manifest blob: %w", err)
}
var man specs.Manifest
err = json.Unmarshal(manifestBlob, &man)
if err != nil {
return nil, fmt.Errorf("image archive unmarshal manifest: %w", err)
}
configBlob, err := content.ReadBlob(ctx, store, man.Config)
if err != nil {
return nil, fmt.Errorf("image archive read image config blob %s: %w", man.Config.Digest, err)
}
var imgSpec specs.Image
err = json.Unmarshal(configBlob, &imgSpec)
if err != nil {
return nil, fmt.Errorf("load image config: %w", err)
}
container.Config = imgSpec.Config
return container, nil
}
func (container *Container) WithExposedPort(port Port) (*Container, error) {
container = container.Clone()
// replace existing port to avoid duplicates
gotOne := false
for i, p := range container.Ports {
if p.Port == port.Port && p.Protocol == port.Protocol {
container.Ports[i] = port
gotOne = true
break
}
}
if !gotOne {
container.Ports = append(container.Ports, port)
}
if container.Config.ExposedPorts == nil {
container.Config.ExposedPorts = map[string]struct{}{}
}
ociPort := fmt.Sprintf("%d/%s", port.Port, port.Protocol.Network())
container.Config.ExposedPorts[ociPort] = struct{}{}
return container, nil
}
func (container *Container) WithoutExposedPort(port int, protocol NetworkProtocol) (*Container, error) {
container = container.Clone()
filtered := []Port{}
filteredOCI := map[string]struct{}{}
for _, p := range container.Ports {
if p.Port != port || p.Protocol != protocol {
filtered = append(filtered, p)
ociPort := fmt.Sprintf("%d/%s", p.Port, p.Protocol.Network())
filteredOCI[ociPort] = struct{}{}
}
}
container.Ports = filtered
container.Config.ExposedPorts = filteredOCI
return container, nil
}
func (container *Container) WithServiceBinding(ctx context.Context, id *idproto.ID, svc *Service, alias string) (*Container, error) {
container = container.Clone()
host, err := svc.Hostname(ctx, id)
if err != nil {
return nil, err
}
var aliases AliasSet
if alias != "" {
aliases = AliasSet{alias}
}
container.Services.Merge(ServiceBindings{
{
ID: id,
Service: svc,
Hostname: host,
Aliases: aliases,
},
})
return container, nil
}
func (container *Container) ImageRefOrErr(ctx context.Context) (string, error) {
imgRef := container.ImageRef
if imgRef != "" {
return imgRef, nil
}
return "", errors.Errorf("Image reference can only be retrieved immediately after the 'Container.From' call. Error in fetching imageRef as the container image is changed")
}
func (container *Container) Service(ctx context.Context) (*Service, error) {
if container.Meta == nil {
var err error
container, err = container.WithExec(ctx, ContainerExecOpts{})
if err != nil {
return nil, err
}
}
return container.Query.NewContainerService(container), nil
}
func (container *Container) ownership(ctx context.Context, owner string) (*Ownership, error) {
if owner == "" {
// do not change ownership
return nil, nil
}
fsSt, err := container.FSState()
if err != nil {
return nil, err
}
return resolveUIDGID(ctx, fsSt, container.Query.Buildkit, container.Platform, owner)
}
func (container *Container) command(opts ContainerExecOpts) ([]string, error) {
cfg := container.Config
args := opts.Args
if len(args) == 0 {
// we use the default args if no new default args are passed
args = cfg.Cmd
}
if len(cfg.Entrypoint) > 0 && !opts.SkipEntrypoint {
args = append(cfg.Entrypoint, args...)
}
if len(args) == 0 {
return nil, errors.New("no command has been set")
}
return args, nil
}
func metaMount(stdin string) (llb.State, string) {
// because the shim might run as non-root, we need to make a world-writable
// directory first and then make it the base of the /dagger mount point.
//
// TODO(vito): have the shim exec as the other user instead?
meta := llb.Mkdir(buildkit.MetaSourcePath, 0o777)
if stdin != "" {
meta = meta.Mkfile(path.Join(buildkit.MetaSourcePath, "stdin"), 0o666, []byte(stdin))
}
return llb.Scratch().File(
meta,
llb.WithCustomName(buildkit.InternalPrefix+"creating dagger metadata"),
),
buildkit.MetaSourcePath
}
type ContainerExecOpts struct {
// Command to run instead of the container's default command
Args []string
// If the container has an entrypoint, ignore it for this exec rather than
// calling it with args.
SkipEntrypoint bool `default:"false"`
// Content to write to the command's standard input before closing
Stdin string `default:""`
// Redirect the command's standard output to a file in the container
RedirectStdout string `default:""`
// Redirect the command's standard error to a file in the container
RedirectStderr string `default:""`
// Provide dagger access to the executed command
// Do not use this option unless you trust the command being executed.
// The command being executed WILL BE GRANTED FULL ACCESS TO YOUR HOST FILESYSTEM
ExperimentalPrivilegedNesting bool `default:"false"`
// Grant the process all root capabilities
InsecureRootCapabilities bool `default:"false"`
// (Internal-only) If this exec is for a module function, this digest will be set in the
// grpc context metadata for any api requests back to the engine. It's used by the API
// server to determine which schema to serve and other module context metadata.
ModuleCallerDigest digest.Digest `name:"-"`
// (Internal-only) Used for module function execs to trigger the nested api client to
// be connected back to the same session.
NestedInSameSession bool `name:"-"`
}
type BuildArg struct {
Name string `field:"true" doc:"The build argument name."`
Value string `field:"true" doc:"The build argument value."`
}
func (BuildArg) TypeName() string {
return "BuildArg"
}
func (BuildArg) TypeDescription() string {
return "Key value object that represents a build argument."
}
// OCI manifest annotation that specifies an image's tag
const ociTagAnnotation = "org.opencontainers.image.ref.name"
func resolveIndex(ctx context.Context, store content.Store, desc specs.Descriptor, platform specs.Platform, tag string) (*specs.Descriptor, error) {
if desc.MediaType != specs.MediaTypeImageIndex {
return nil, fmt.Errorf("expected index, got %s", desc.MediaType)
}
indexBlob, err := content.ReadBlob(ctx, store, desc)
if err != nil {
return nil, fmt.Errorf("read index blob: %w", err)
}
var idx specs.Index
err = json.Unmarshal(indexBlob, &idx)
if err != nil {
return nil, fmt.Errorf("unmarshal index: %w", err)
}
matcher := platforms.Only(platform)
for _, m := range idx.Manifests {
if m.Platform != nil {
if !matcher.Match(*m.Platform) {
// incompatible
continue
}
}
if tag != "" {
if m.Annotations == nil {
continue
}
manifestTag, found := m.Annotations[ociTagAnnotation]
if !found || manifestTag != tag {
continue
}
}
switch m.MediaType {
case specs.MediaTypeImageManifest, // OCI
images.MediaTypeDockerSchema2Manifest: // Docker
return &m, nil
case specs.MediaTypeImageIndex, // OCI
images.MediaTypeDockerSchema2ManifestList: // Docker
return resolveIndex(ctx, store, m, platform, tag)
default:
return nil, fmt.Errorf("expected manifest or index, got %s", m.MediaType)
}
}
return nil, fmt.Errorf("no manifest for platform %s and tag %s", platforms.Format(platform), tag)
}
type ImageLayerCompression string
var ImageLayerCompressions = dagql.NewEnum[ImageLayerCompression]()
var (
CompressionGzip = ImageLayerCompressions.Register("Gzip")
CompressionZstd = ImageLayerCompressions.Register("Zstd")
CompressionEStarGZ = ImageLayerCompressions.Register("EStarGZ")
CompressionUncompressed = ImageLayerCompressions.Register("Uncompressed")
)
func (proto ImageLayerCompression) Type() *ast.Type {
return &ast.Type{
NamedType: "ImageLayerCompression",
NonNull: true,
}
}
func (proto ImageLayerCompression) TypeDescription() string {
return "Compression algorithm to use for image layers."
}
func (proto ImageLayerCompression) Decoder() dagql.InputDecoder {
return ImageLayerCompressions
}
func (proto ImageLayerCompression) ToLiteral() *idproto.Literal {
return ImageLayerCompressions.Literal(proto)
}
type ImageMediaTypes string
var ImageMediaTypesEnum = dagql.NewEnum[ImageMediaTypes]()
var (
OCIMediaTypes = ImageMediaTypesEnum.Register("OCIMediaTypes")
DockerMediaTypes = ImageMediaTypesEnum.Register("DockerMediaTypes")
)
func (proto ImageMediaTypes) Type() *ast.Type {
return &ast.Type{
NamedType: "ImageMediaTypes",
NonNull: true,
}
}
func (proto ImageMediaTypes) TypeDescription() string {
return "Mediatypes to use in published or exported image metadata."
}
func (proto ImageMediaTypes) Decoder() dagql.InputDecoder {
return ImageMediaTypesEnum
}
func (proto ImageMediaTypes) ToLiteral() *idproto.Literal {
return ImageMediaTypesEnum.Literal(proto)
}
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,828 | Panic in `terminal` if no args set | Think this is a regression in v0.10.1 cc @TomChv
See https://github.com/dagger/dagger/pull/6805/files#r1513137070
```
goroutine 457496 [running]:
runtime/debug.Stack()
/usr/local/go/src/runtime/debug/stack.go:24 +0x5e
github.com/dagger/dagger/dagql.(*Server).resolvePath.func1()
/app/dagql/server.go:642 +0x74
panic({0x1bd65a0?, 0x3139130?})
/usr/local/go/src/runtime/panic.go:914 +0x21f
github.com/dagger/dagger/core/schema.(*containerSchema).terminal(0x1d3a040?, {0x2299038, 0xc00330eea0}, {0xc005579280, 0xc00305f340, {0x0, 0x1, 0xc0033daf60, 0xc00394bed8}, 0x0}, ...)
/app/core/schema/container.go:1366 +0xc9
github.com/dagger/dagger/dagql.NodeFunc[...].func1({0xc005579280, 0xc00305f340, {0x0, 0x1, 0xc0033daf60, 0xc00394bed8}, 0x0}, 0xc00330ef00)
/app/dagql/objects.go:355 +0x184
github.com/dagger/dagger/dagql.Class[...].Call(0x22c3500?, {0x2299038?, 0xc00330eea0?}, {0xc005579280, 0xc00305f340, {0x0, 0x1, 0xc0033daf60, 0xc00394bed8}, 0x0}, ...)
/app/dagql/objects.go:202 +0x15d
github.com/dagger/dagger/dagql.Instance[...].Select(0x22b3a20, {0x2299038, 0xc00330eea0}, {{0xc000cd2508, 0x8}, {0x319c680, 0x0, 0x0}, 0x0})
/app/dagql/objects.go:271 +0x2fe
github.com/dagger/dagger/dagql.(*Server).cachedSelect.func1({0x2299038?, 0xc00330eea0?})
/app/dagql/server.go:583 +0x49
github.com/dagger/dagger/tracing.AroundFunc.ProgrockAroundFunc.func1({0x2299038, 0xc00330ed80})
/app/tracing/graphql.go:102 +0x5c4
github.com/dagger/dagger/tracing.AroundFunc.SpanAroundFunc.func2({0x2299038, 0xc003e691a0})
/app/tracing/graphql.go:33 +0xa6
github.com/dagger/dagger/dagql.(*cacheMap[...]).GetOrInitializeOnHit(0x22bf680, {0x2299038, 0xc003e68ea0}, {0xc003775130, 0x47}, 0xc004ccb788, 0xc0031f9b08)
/app/dagql/cachemap.go:85 +0x272
github.com/dagger/dagger/dagql.(*cacheMap[...]).GetOrInitialize(0xc0031f9b48?, {0x2299038?, 0xc003e68ea0?}, {0xc003775130?, 0x10c0f25?}, 0x229c200?)
/app/dagql/cachemap.go:60 +0x45
github.com/dagger/dagger/dagql.(*Server).cachedSelect(0xc003e1a4b0, {0x2299038, 0xc004a82630}, {0x229c200, 0xc002c9ac40}, {{0xc000cd2508, 0x8}, {0x319c680, 0x0, 0x0}, ...})
/app/dagql/server.go:592 +0x203
github.com/dagger/dagger/dagql.(*Server).resolvePath(0x1052c6b?, {0x2299038, 0xc004a82630}, {0x229c200?, 0xc002c9ac40?}, {{0xc000cd2508, 0x8}, {{0xc000cd2508, 0x8}, {0x319c680, ...}, ...}, ...})
/app/dagql/server.go:651 +0x13e
github.com/dagger/dagger/dagql.(*Server).Resolve.func1()
/app/dagql/server.go:405 +0x7f
github.com/dagger/dagger/dagql.(*Server).Resolve.(*ErrorPool).Go.func3()
/go/pkg/mod/github.com/sourcegraph/[email protected]/pool/error_pool.go:30 +0x22
github.com/sourcegraph/conc/pool.(*Pool).worker(0xc001825858?)
/go/pkg/mod/github.com/sourcegraph/[email protected]/pool/pool.go:154 +0x6f
github.com/sourcegraph/conc/panics.(*Catcher).Try(0x445edc?, 0x6?)
/go/pkg/mod/github.com/sourcegraph/[email protected]/panics/panics.go:23 +0x48
github.com/sourcegraph/conc.(*WaitGroup).Go.func1()
/go/pkg/mod/github.com/sourcegraph/[email protected]/waitgroup.go:32 +0x56
created by github.com/sourcegraph/conc.(*WaitGroup).Go in goroutine 372437
/go/pkg/mod/github.com/sourcegraph/[email protected]/waitgroup.go:30 +0x73
```
I can hit this if I `terminal` a container that doesn't have default args, and hasn't called `withDefaultTerminalCmd`. | https://github.com/dagger/dagger/issues/6828 | https://github.com/dagger/dagger/pull/6838 | e5f0bc7389dc0ba454fa8247de023e4a92efb1c2 | 7b69661a44e419b03d94264b74c3e99d6e98cf0d | "2024-03-05T16:34:06Z" | go | "2024-03-06T14:03:34Z" | core/integration/module_terminal_test.go | package core
import (
"bytes"
"context"
"fmt"
"io"
"os"
"path/filepath"
"regexp"
"testing"
"time"
"github.com/Netflix/go-expect"
"github.com/creack/pty"
"github.com/stretchr/testify/require"
)
// Terminal tests are run directly on the host rather than in exec containers because we want to
// directly interact with the dagger shell tui without resorting to embedding more go code
// into a container for driving it.
func TestModuleDaggerTerminal(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
t.Run("basic", func(t *testing.T) {
modDir := t.TempDir()
err := os.WriteFile(filepath.Join(modDir, "main.go"), []byte(`package main
import "context"
func New(ctx context.Context) *Test {
return &Test{
Ctr: dag.Container().
From("mirror.gcr.io/alpine:3.18").
WithEnvVariable("COOLENV", "woo").
WithWorkdir("/coolworkdir").
WithDefaultTerminalCmd([]string{"/bin/sh"}),
}
}
type Test struct {
Ctr *Container
}
`), 0644)
require.NoError(t, err)
_, err = hostDaggerExec(ctx, t, modDir, "--debug", "init", "--source=.", "--name=test", "--sdk=go")
require.NoError(t, err)
// cache the module load itself so there's less to wait for in the shell invocation below
_, err = hostDaggerExec(ctx, t, modDir, "--debug", "functions")
require.NoError(t, err)
// timeout for waiting for each expected line is very generous in case CI is under heavy load or something
console, err := newTUIConsole(t, 60*time.Second)
require.NoError(t, err)
defer console.Close()
tty := console.Tty()
// We want the size to be big enough to fit the output we're expecting, but increasing
// the size also eventually slows down the tests due to more output being generated and
// needing parsing.
err = pty.Setsize(tty, &pty.Winsize{Rows: 6, Cols: 16})
require.NoError(t, err)
cmd := hostDaggerCommand(ctx, t, modDir, "call", "ctr", "terminal")
cmd.Stdin = tty
cmd.Stdout = tty
cmd.Stderr = tty
err = cmd.Start()
require.NoError(t, err)
_, err = console.ExpectString("/coolworkdir #")
require.NoError(t, err)
_, err = console.SendLine("echo $COOLENV")
require.NoError(t, err)
err = console.ExpectLineRegex(ctx, "woo")
require.NoError(t, err)
_, err = console.ExpectString("/coolworkdir #")
require.NoError(t, err)
_, err = console.SendLine("exit")
require.NoError(t, err)
go console.ExpectEOF()
err = cmd.Wait()
require.NoError(t, err)
})
t.Run("override args", func(t *testing.T) {
modDir := t.TempDir()
err := os.WriteFile(filepath.Join(modDir, "main.go"), []byte(`package main
import "context"
func New(ctx context.Context) *Test {
return &Test{
Ctr: dag.Container().
From("mirror.gcr.io/alpine:3.18").
WithEnvVariable("COOLENV", "woo").
WithWorkdir("/coolworkdir").
WithExec([]string{"apk", "add", "python3"}).
WithDefaultTerminalCmd([]string{"/bin/sh"}),
}
}
type Test struct {
Ctr *Container
}
`), 0644)
require.NoError(t, err)
_, err = hostDaggerExec(ctx, t, modDir, "--debug", "init", "--source=.", "--name=test", "--sdk=go")
require.NoError(t, err)
// cache the returned container so there's less to wait for in the shell invocation below
_, err = hostDaggerExec(ctx, t, modDir, "--debug", "call", "ctr", "sync")
require.NoError(t, err)
console, err := newTUIConsole(t, 60*time.Second)
require.NoError(t, err)
defer console.Close()
tty := console.Tty()
err = pty.Setsize(tty, &pty.Winsize{Rows: 5, Cols: 22})
require.NoError(t, err)
cmd := hostDaggerCommand(ctx, t, modDir, "call", "ctr", "terminal", "--cmd=python")
cmd.Stdin = tty
cmd.Stdout = tty
cmd.Stderr = tty
err = cmd.Start()
require.NoError(t, err)
_, err = console.ExpectString(">>> ")
require.NoError(t, err)
_, err = console.SendLine("import os")
require.NoError(t, err)
_, err = console.ExpectString(">>> ")
require.NoError(t, err)
_, err = console.SendLine("os.environ['COOLENV']")
require.NoError(t, err)
err = console.ExpectLineRegex(ctx, "'woo'")
require.NoError(t, err)
_, err = console.SendLine("exit()")
require.NoError(t, err)
go console.ExpectEOF()
err = cmd.Wait()
require.NoError(t, err)
})
}
// tuiConsole wraps expect.Console with methods that allow us to enforce
// timeouts despite the fact that the TUI is constantly writing more data
// (which invalidates the expect lib's builtin read timeout mechanisms).
type tuiConsole struct {
*expect.Console
expectLineTimeout time.Duration
output *bytes.Buffer
}
func newTUIConsole(t *testing.T, expectLineTimeout time.Duration) (*tuiConsole, error) {
output := bytes.NewBuffer(nil)
console, err := expect.NewConsole(
expect.WithStdout(io.MultiWriter(newTWriter(t), output)),
expect.WithDefaultTimeout(expectLineTimeout),
)
if err != nil {
return nil, err
}
t.Cleanup(func() {
console.Close()
})
return &tuiConsole{
Console: console,
expectLineTimeout: expectLineTimeout,
output: output,
}, nil
}
func (e *tuiConsole) ExpectLineRegex(ctx context.Context, pattern string) error {
_, _, err := e.MatchLine(ctx, pattern)
return err
}
func (e *tuiConsole) MatchLine(ctx context.Context, pattern string) (string, []string, error) {
re, err := regexp.Compile(pattern)
if err != nil {
return "", nil, err
}
ctx, cancel := context.WithTimeout(ctx, e.expectLineTimeout)
defer cancel()
lineMatcher := expect.RegexpPattern(".*\n")
for {
select {
case <-ctx.Done():
return "", nil, fmt.Errorf("timed out waiting for line matching %q, most recent output:\n%s", pattern, e.output.String())
default:
}
line, err := e.Expect(lineMatcher)
if err != nil {
return "", nil, err
}
if matches := re.FindStringSubmatch(line); matches != nil {
return line, matches, nil
}
}
}
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,828 | Panic in `terminal` if no args set | Think this is a regression in v0.10.1 cc @TomChv
See https://github.com/dagger/dagger/pull/6805/files#r1513137070
```
goroutine 457496 [running]:
runtime/debug.Stack()
/usr/local/go/src/runtime/debug/stack.go:24 +0x5e
github.com/dagger/dagger/dagql.(*Server).resolvePath.func1()
/app/dagql/server.go:642 +0x74
panic({0x1bd65a0?, 0x3139130?})
/usr/local/go/src/runtime/panic.go:914 +0x21f
github.com/dagger/dagger/core/schema.(*containerSchema).terminal(0x1d3a040?, {0x2299038, 0xc00330eea0}, {0xc005579280, 0xc00305f340, {0x0, 0x1, 0xc0033daf60, 0xc00394bed8}, 0x0}, ...)
/app/core/schema/container.go:1366 +0xc9
github.com/dagger/dagger/dagql.NodeFunc[...].func1({0xc005579280, 0xc00305f340, {0x0, 0x1, 0xc0033daf60, 0xc00394bed8}, 0x0}, 0xc00330ef00)
/app/dagql/objects.go:355 +0x184
github.com/dagger/dagger/dagql.Class[...].Call(0x22c3500?, {0x2299038?, 0xc00330eea0?}, {0xc005579280, 0xc00305f340, {0x0, 0x1, 0xc0033daf60, 0xc00394bed8}, 0x0}, ...)
/app/dagql/objects.go:202 +0x15d
github.com/dagger/dagger/dagql.Instance[...].Select(0x22b3a20, {0x2299038, 0xc00330eea0}, {{0xc000cd2508, 0x8}, {0x319c680, 0x0, 0x0}, 0x0})
/app/dagql/objects.go:271 +0x2fe
github.com/dagger/dagger/dagql.(*Server).cachedSelect.func1({0x2299038?, 0xc00330eea0?})
/app/dagql/server.go:583 +0x49
github.com/dagger/dagger/tracing.AroundFunc.ProgrockAroundFunc.func1({0x2299038, 0xc00330ed80})
/app/tracing/graphql.go:102 +0x5c4
github.com/dagger/dagger/tracing.AroundFunc.SpanAroundFunc.func2({0x2299038, 0xc003e691a0})
/app/tracing/graphql.go:33 +0xa6
github.com/dagger/dagger/dagql.(*cacheMap[...]).GetOrInitializeOnHit(0x22bf680, {0x2299038, 0xc003e68ea0}, {0xc003775130, 0x47}, 0xc004ccb788, 0xc0031f9b08)
/app/dagql/cachemap.go:85 +0x272
github.com/dagger/dagger/dagql.(*cacheMap[...]).GetOrInitialize(0xc0031f9b48?, {0x2299038?, 0xc003e68ea0?}, {0xc003775130?, 0x10c0f25?}, 0x229c200?)
/app/dagql/cachemap.go:60 +0x45
github.com/dagger/dagger/dagql.(*Server).cachedSelect(0xc003e1a4b0, {0x2299038, 0xc004a82630}, {0x229c200, 0xc002c9ac40}, {{0xc000cd2508, 0x8}, {0x319c680, 0x0, 0x0}, ...})
/app/dagql/server.go:592 +0x203
github.com/dagger/dagger/dagql.(*Server).resolvePath(0x1052c6b?, {0x2299038, 0xc004a82630}, {0x229c200?, 0xc002c9ac40?}, {{0xc000cd2508, 0x8}, {{0xc000cd2508, 0x8}, {0x319c680, ...}, ...}, ...})
/app/dagql/server.go:651 +0x13e
github.com/dagger/dagger/dagql.(*Server).Resolve.func1()
/app/dagql/server.go:405 +0x7f
github.com/dagger/dagger/dagql.(*Server).Resolve.(*ErrorPool).Go.func3()
/go/pkg/mod/github.com/sourcegraph/[email protected]/pool/error_pool.go:30 +0x22
github.com/sourcegraph/conc/pool.(*Pool).worker(0xc001825858?)
/go/pkg/mod/github.com/sourcegraph/[email protected]/pool/pool.go:154 +0x6f
github.com/sourcegraph/conc/panics.(*Catcher).Try(0x445edc?, 0x6?)
/go/pkg/mod/github.com/sourcegraph/[email protected]/panics/panics.go:23 +0x48
github.com/sourcegraph/conc.(*WaitGroup).Go.func1()
/go/pkg/mod/github.com/sourcegraph/[email protected]/waitgroup.go:32 +0x56
created by github.com/sourcegraph/conc.(*WaitGroup).Go in goroutine 372437
/go/pkg/mod/github.com/sourcegraph/[email protected]/waitgroup.go:30 +0x73
```
I can hit this if I `terminal` a container that doesn't have default args, and hasn't called `withDefaultTerminalCmd`. | https://github.com/dagger/dagger/issues/6828 | https://github.com/dagger/dagger/pull/6838 | e5f0bc7389dc0ba454fa8247de023e4a92efb1c2 | 7b69661a44e419b03d94264b74c3e99d6e98cf0d | "2024-03-05T16:34:06Z" | go | "2024-03-06T14:03:34Z" | core/schema/container.go | package schema
import (
"context"
"fmt"
"io/fs"
"log/slog"
"os"
"path"
"strconv"
"strings"
"time"
"github.com/dagger/dagger/core"
"github.com/dagger/dagger/core/pipeline"
"github.com/dagger/dagger/dagql"
"github.com/moby/buildkit/frontend/dockerfile/shell"
specs "github.com/opencontainers/image-spec/specs-go/v1"
"github.com/vektah/gqlparser/v2/ast"
)
type containerSchema struct {
srv *dagql.Server
}
var _ SchemaResolvers = &containerSchema{}
func (s *containerSchema) Install() {
dagql.Fields[*core.Query]{
dagql.Func("container", s.container).
Doc(`Creates a scratch container.`,
`Optional platform argument initializes new containers to execute and
publish as that platform. Platform defaults to that of the builder's
host.`).
ArgDoc("platform", `Platform to initialize the container with.`).
ArgDeprecated("id", "Use `loadContainerFromID` instead."),
}.Install(s.srv)
dagql.Fields[*core.Container]{
Syncer[*core.Container]().
Doc(`Forces evaluation of the pipeline in the engine.`,
`It doesn't run the default command if no exec has been set.`),
dagql.Func("pipeline", s.pipeline).
Doc(`Creates a named sub-pipeline.`).
ArgDoc("name", "Name of the sub-pipeline.").
ArgDoc("description", "Description of the sub-pipeline.").
ArgDoc("labels", "Labels to apply to the sub-pipeline."),
dagql.Func("from", s.from).
Doc(`Initializes this container from a pulled base image.`).
ArgDoc("address",
`Image's address from its registry.`,
`Formatted as [host]/[user]/[repo]:[tag] (e.g., "docker.io/dagger/dagger:main").`),
dagql.Func("build", s.build).
Doc(`Initializes this container from a Dockerfile build.`).
ArgDoc("context", "Directory context used by the Dockerfile.").
ArgDoc("dockerfile", "Path to the Dockerfile to use.").
ArgDoc("buildArgs", "Additional build arguments.").
ArgDoc("target", "Target build stage to build.").
ArgDoc("secrets",
`Secrets to pass to the build.`,
`They will be mounted at /run/secrets/[secret-name] in the build container`,
`They can be accessed in the Dockerfile using the "secret" mount type
and mount path /run/secrets/[secret-name], e.g. RUN
--mount=type=secret,id=my-secret curl [http://example.com?token=$(cat
/run/secrets/my-secret)](http://example.com?token=$(cat
/run/secrets/my-secret))`),
dagql.Func("rootfs", s.rootfs).
Doc(`Retrieves this container's root filesystem. Mounts are not included.`),
dagql.Func("withRootfs", s.withRootfs).
Doc(`Retrieves the container with the given directory mounted to /.`).
ArgDoc("directory", "Directory to mount."),
dagql.Func("directory", s.directory).
Doc(`Retrieves a directory at the given path.`,
`Mounts are included.`).
ArgDoc("path", `The path of the directory to retrieve (e.g., "./src").`),
dagql.Func("file", s.file).
Doc(`Retrieves a file at the given path.`, `Mounts are included.`).
ArgDoc("path", `The path of the file to retrieve (e.g., "./README.md").`),
dagql.Func("user", s.user).
Doc("Retrieves the user to be set for all commands."),
dagql.Func("withUser", s.withUser).
Doc(`Retrieves this container with a different command user.`).
ArgDoc("name", `The user to set (e.g., "root").`),
dagql.Func("withoutUser", s.withoutUser).
Doc(`Retrieves this container with an unset command user.`,
`Should default to root.`),
dagql.Func("workdir", s.workdir).
Doc("Retrieves the working directory for all commands."),
dagql.Func("withWorkdir", s.withWorkdir).
Doc(`Retrieves this container with a different working directory.`).
ArgDoc("path", `The path to set as the working directory (e.g., "/app").`),
dagql.Func("withoutWorkdir", s.withoutWorkdir).
Doc(`Retrieves this container with an unset working directory.`,
`Should default to "/".`),
dagql.Func("envVariables", s.envVariables).
Doc(`Retrieves the list of environment variables passed to commands.`),
dagql.Func("envVariable", s.envVariable).
Doc(`Retrieves the value of the specified environment variable.`).
ArgDoc("name", `The name of the environment variable to retrieve (e.g., "PATH").`),
dagql.Func("withEnvVariable", s.withEnvVariable).
Doc(`Retrieves this container plus the given environment variable.`).
ArgDoc("name", `The name of the environment variable (e.g., "HOST").`).
ArgDoc("value", `The value of the environment variable. (e.g., "localhost").`).
ArgDoc("expand",
"Replace `${VAR}` or `$VAR` in the value according to the current "+
`environment variables defined in the container (e.g.,
"/opt/bin:$PATH").`),
dagql.Func("withSecretVariable", s.withSecretVariable).
Doc(`Retrieves this container plus an env variable containing the given secret.`).
ArgDoc("name", `The name of the secret variable (e.g., "API_SECRET").`).
ArgDoc("secret", `The identifier of the secret value.`),
dagql.Func("withoutEnvVariable", s.withoutEnvVariable).
Doc(`Retrieves this container minus the given environment variable.`).
ArgDoc("name", `The name of the environment variable (e.g., "HOST").`),
dagql.Func("withLabel", s.withLabel).
Doc(`Retrieves this container plus the given label.`).
ArgDoc("name", `The name of the label (e.g., "org.opencontainers.artifact.created").`).
ArgDoc("value", `The value of the label (e.g., "2023-01-01T00:00:00Z").`),
dagql.Func("label", s.label).
Doc(`Retrieves the value of the specified label.`).
ArgDoc("name", `The name of the label (e.g., "org.opencontainers.artifact.created").`),
dagql.Func("labels", s.labels).
Doc(`Retrieves the list of labels passed to container.`),
dagql.Func("withoutLabel", s.withoutLabel).
Doc(`Retrieves this container minus the given environment label.`).
ArgDoc("name", `The name of the label to remove (e.g., "org.opencontainers.artifact.created").`),
dagql.Func("entrypoint", s.entrypoint).
Doc(`Retrieves entrypoint to be prepended to the arguments of all commands.`),
dagql.Func("withEntrypoint", s.withEntrypoint).
Doc(`Retrieves this container but with a different command entrypoint.`).
ArgDoc("args", `Entrypoint to use for future executions (e.g., ["go", "run"]).`).
ArgDoc("keepDefaultArgs", `Don't remove the default arguments when setting the entrypoint.`),
dagql.Func("withoutEntrypoint", s.withoutEntrypoint).
Doc(`Retrieves this container with an unset command entrypoint.`).
ArgDoc("keepDefaultArgs", `Don't remove the default arguments when unsetting the entrypoint.`),
dagql.Func("defaultArgs", s.defaultArgs).
Doc(`Retrieves default arguments for future commands.`),
dagql.Func("withDefaultArgs", s.withDefaultArgs).
Doc(`Configures default arguments for future commands.`).
ArgDoc("args", `Arguments to prepend to future executions (e.g., ["-v", "--no-cache"]).`),
dagql.Func("withoutDefaultArgs", s.withoutDefaultArgs).
Doc(`Retrieves this container with unset default arguments for future commands.`),
dagql.Func("mounts", s.mounts).
Doc(`Retrieves the list of paths where a directory is mounted.`),
dagql.Func("withMountedDirectory", s.withMountedDirectory).
Doc(`Retrieves this container plus a directory mounted at the given path.`).
ArgDoc("path", `Location of the mounted directory (e.g., "/mnt/directory").`).
ArgDoc("source", `Identifier of the mounted directory.`).
ArgDoc("owner",
`A user:group to set for the mounted directory and its contents.`,
`The user and group can either be an ID (1000:1000) or a name (foo:bar).`,
`If the group is omitted, it defaults to the same as the user.`),
dagql.Func("withMountedFile", s.withMountedFile).
Doc(`Retrieves this container plus a file mounted at the given path.`).
ArgDoc("path", `Location of the mounted file (e.g., "/tmp/file.txt").`).
ArgDoc("source", `Identifier of the mounted file.`).
ArgDoc("owner",
`A user or user:group to set for the mounted file.`,
`The user and group can either be an ID (1000:1000) or a name (foo:bar).`,
`If the group is omitted, it defaults to the same as the user.`),
dagql.Func("withMountedTemp", s.withMountedTemp).
Doc(`Retrieves this container plus a temporary directory mounted at the given path.`).
ArgDoc("path", `Location of the temporary directory (e.g., "/tmp/temp_dir").`),
dagql.Func("withMountedCache", s.withMountedCache).
Doc(`Retrieves this container plus a cache volume mounted at the given path.`).
ArgDoc("path", `Location of the cache directory (e.g., "/cache/node_modules").`).
ArgDoc("cache", `Identifier of the cache volume to mount.`).
ArgDoc("source", `Identifier of the directory to use as the cache volume's root.`).
ArgDoc("sharing", `Sharing mode of the cache volume.`).
ArgDoc("owner",
`A user:group to set for the mounted cache directory.`,
`Note that this changes the ownership of the specified mount along with
the initial filesystem provided by source (if any). It does not have
any effect if/when the cache has already been created.`,
`The user and group can either be an ID (1000:1000) or a name (foo:bar).`,
`If the group is omitted, it defaults to the same as the user.`),
dagql.Func("withMountedSecret", s.withMountedSecret).
Doc(`Retrieves this container plus a secret mounted into a file at the given path.`).
ArgDoc("path", `Location of the secret file (e.g., "/tmp/secret.txt").`).
ArgDoc("source", `Identifier of the secret to mount.`).
ArgDoc("owner",
`A user:group to set for the mounted secret.`,
`The user and group can either be an ID (1000:1000) or a name (foo:bar).`,
`If the group is omitted, it defaults to the same as the user.`).
ArgDoc("mode", `Permission given to the mounted secret (e.g., 0600).`,
`This option requires an owner to be set to be active.`),
dagql.Func("withUnixSocket", s.withUnixSocket).
Doc(`Retrieves this container plus a socket forwarded to the given Unix socket path.`).
ArgDoc("path", `Location of the forwarded Unix socket (e.g., "/tmp/socket").`).
ArgDoc("source", `Identifier of the socket to forward.`).
ArgDoc("owner",
`A user:group to set for the mounted socket.`,
`The user and group can either be an ID (1000:1000) or a name (foo:bar).`,
`If the group is omitted, it defaults to the same as the user.`),
dagql.Func("withoutUnixSocket", s.withoutUnixSocket).
Doc(`Retrieves this container with a previously added Unix socket removed.`).
ArgDoc("path", `Location of the socket to remove (e.g., "/tmp/socket").`),
dagql.Func("withoutMount", s.withoutMount).
Doc(`Retrieves this container after unmounting everything at the given path.`).
ArgDoc("path", `Location of the cache directory (e.g., "/cache/node_modules").`),
dagql.Func("withFile", s.withFile).
Doc(`Retrieves this container plus the contents of the given file copied to the given path.`).
ArgDoc("path", `Location of the copied file (e.g., "/tmp/file.txt").`).
ArgDoc("source", `Identifier of the file to copy.`).
ArgDoc("permissions", `Permission given to the copied file (e.g., 0600).`).
ArgDoc("owner",
`A user:group to set for the file.`,
`The user and group can either be an ID (1000:1000) or a name (foo:bar).`,
`If the group is omitted, it defaults to the same as the user.`),
dagql.Func("withFiles", s.withFiles).
Doc(`Retrieves this container plus the contents of the given files copied to the given path.`).
ArgDoc("path", `Location where copied files should be placed (e.g., "/src").`).
ArgDoc("sources", `Identifiers of the files to copy.`).
ArgDoc("permissions", `Permission given to the copied files (e.g., 0600).`).
ArgDoc("owner",
`A user:group to set for the files.`,
`The user and group can either be an ID (1000:1000) or a name (foo:bar).`,
`If the group is omitted, it defaults to the same as the user.`),
dagql.Func("withNewFile", s.withNewFile).
Doc(`Retrieves this container plus a new file written at the given path.`).
ArgDoc("path", `Location of the written file (e.g., "/tmp/file.txt").`).
ArgDoc("contents", `Content of the file to write (e.g., "Hello world!").`).
ArgDoc("permissions", `Permission given to the written file (e.g., 0600).`).
ArgDoc("owner",
`A user:group to set for the file.`,
`The user and group can either be an ID (1000:1000) or a name (foo:bar).`,
`If the group is omitted, it defaults to the same as the user.`),
dagql.Func("withDirectory", s.withDirectory).
Doc(`Retrieves this container plus a directory written at the given path.`).
ArgDoc("path", `Location of the written directory (e.g., "/tmp/directory").`).
ArgDoc("directory", `Identifier of the directory to write`).
ArgDoc("exclude", `Patterns to exclude in the written directory (e.g. ["node_modules/**", ".gitignore", ".git/"]).`).
ArgDoc("include", `Patterns to include in the written directory (e.g. ["*.go", "go.mod", "go.sum"]).`).
ArgDoc("owner",
`A user:group to set for the directory and its contents.`,
`The user and group can either be an ID (1000:1000) or a name (foo:bar).`,
`If the group is omitted, it defaults to the same as the user.`),
dagql.Func("withExec", s.withExec).
Doc(`Retrieves this container after executing the specified command inside it.`).
ArgDoc("args",
`Command to run instead of the container's default command (e.g., ["run", "main.go"]).`,
`If empty, the container's default command is used.`).
ArgDoc("skipEntrypoint",
`If the container has an entrypoint, ignore it for args rather than using it to wrap them.`).
ArgDoc("stdin",
`Content to write to the command's standard input before closing (e.g.,
"Hello world").`).
ArgDoc("redirectStdout",
`Redirect the command's standard output to a file in the container (e.g.,
"/tmp/stdout").`).
ArgDoc("redirectStderr",
`Redirect the command's standard error to a file in the container (e.g.,
"/tmp/stderr").`).
ArgDoc("experimentalPrivilegedNesting",
`Provides Dagger access to the executed command.`,
`Do not use this option unless you trust the command being executed;
the command being executed WILL BE GRANTED FULL ACCESS TO YOUR HOST
FILESYSTEM.`).
ArgDoc("insecureRootCapabilities",
`Execute the command with all root capabilities. This is similar to
running a command with "sudo" or executing "docker run" with the
"--privileged" flag. Containerization does not provide any security
guarantees when using this option. It should only be used when
absolutely necessary and only with trusted commands.`),
dagql.Func("stdout", s.stdout).
Doc(`The output stream of the last executed command.`,
`Will execute default command if none is set, or error if there's no default.`),
dagql.Func("stderr", s.stderr).
Doc(`The error stream of the last executed command.`,
`Will execute default command if none is set, or error if there's no default.`),
dagql.Func("publish", s.publish).
Impure("Writes to the specified Docker registry.").
Doc(`Publishes this container as a new image to the specified address.`,
`Publish returns a fully qualified ref.`,
`It can also publish platform variants.`).
ArgDoc("address",
`Registry's address to publish the image to.`,
`Formatted as [host]/[user]/[repo]:[tag] (e.g. "docker.io/dagger/dagger:main").`).
ArgDoc("platformVariants",
`Identifiers for other platform specific containers.`,
`Used for multi-platform image.`).
ArgDoc("forcedCompression",
`Force each layer of the published image to use the specified
compression algorithm.`,
`If this is unset, then if a layer already has a compressed blob in the
engine's cache, that will be used (this can result in a mix of
compression algorithms for different layers). If this is unset and a
layer has no compressed blob in the engine's cache, then it will be
compressed using Gzip.`).
ArgDoc("mediaTypes",
`Use the specified media types for the published image's layers.`,
`Defaults to OCI, which is largely compatible with most recent
registries, but Docker may be needed for older registries without OCI
support.`),
dagql.Func("platform", s.platform).
Doc(`The platform this container executes and publishes as.`),
dagql.Func("export", s.export).
Impure("Writes to the local host.").
Doc(`Writes the container as an OCI tarball to the destination file path on the host.`,
`Return true on success.`,
`It can also export platform variants.`).
ArgDoc("path",
`Host's destination path (e.g., "./tarball").`,
`Path can be relative to the engine's workdir or absolute.`).
ArgDoc("platformVariants",
`Identifiers for other platform specific containers.`,
`Used for multi-platform image.`).
ArgDoc("forcedCompression",
`Force each layer of the exported image to use the specified compression algorithm.`,
`If this is unset, then if a layer already has a compressed blob in the
engine's cache, that will be used (this can result in a mix of
compression algorithms for different layers). If this is unset and a
layer has no compressed blob in the engine's cache, then it will be
compressed using Gzip.`).
ArgDoc("mediaTypes",
`Use the specified media types for the exported image's layers.`,
`Defaults to OCI, which is largely compatible with most recent
container runtimes, but Docker may be needed for older runtimes without
OCI support.`),
dagql.Func("asTarball", s.asTarball).
Doc(`Returns a File representing the container serialized to a tarball.`).
ArgDoc("platformVariants",
`Identifiers for other platform specific containers.`,
`Used for multi-platform images.`).
ArgDoc("forcedCompression",
`Force each layer of the image to use the specified compression algorithm.`,
`If this is unset, then if a layer already has a compressed blob in the
engine's cache, that will be used (this can result in a mix of
compression algorithms for different layers). If this is unset and a
layer has no compressed blob in the engine's cache, then it will be
compressed using Gzip.`).
ArgDoc("mediaTypes", `Use the specified media types for the image's layers.`,
`Defaults to OCI, which is largely compatible with most recent
container runtimes, but Docker may be needed for older runtimes without
OCI support.`),
dagql.Func("import", s.import_).
Doc(`Reads the container from an OCI tarball.`).
ArgDoc("source", `File to read the container from.`).
ArgDoc("tag", `Identifies the tag to import from the archive, if the archive bundles multiple tags.`),
dagql.Func("withRegistryAuth", s.withRegistryAuth).
Doc(`Retrieves this container with a registry authentication for a given address.`).
ArgDoc("address",
`Registry's address to bind the authentication to.`,
`Formatted as [host]/[user]/[repo]:[tag] (e.g. docker.io/dagger/dagger:main).`).
ArgDoc("username", `The username of the registry's account (e.g., "Dagger").`).
ArgDoc("secret", `The API key, password or token to authenticate to this registry.`),
dagql.Func("withoutRegistryAuth", s.withoutRegistryAuth).
Doc(`Retrieves this container without the registry authentication of a given address.`).
ArgDoc("address", `Registry's address to remove the authentication from.`,
`Formatted as [host]/[user]/[repo]:[tag] (e.g. docker.io/dagger/dagger:main).`),
dagql.Func("imageRef", s.imageRef).
Doc(`The unique image reference which can only be retrieved immediately after the 'Container.From' call.`),
dagql.Func("withExposedPort", s.withExposedPort).
Doc(`Expose a network port.`,
`Exposed ports serve two purposes:`,
`- For health checks and introspection, when running services`,
`- For setting the EXPOSE OCI field when publishing the container`).
ArgDoc("port", `Port number to expose`).
ArgDoc("protocol", `Transport layer network protocol`).
ArgDoc("description", `Optional port description`).
ArgDoc("experimentalSkipHealthcheck", `Skip the health check when run as a service.`),
dagql.Func("withoutExposedPort", s.withoutExposedPort).
Doc(`Unexpose a previously exposed port.`).
ArgDoc("port", `Port number to unexpose`).
ArgDoc("protocol", `Port protocol to unexpose`),
dagql.Func("exposedPorts", s.exposedPorts).
Doc(`Retrieves the list of exposed ports.`,
`This includes ports already exposed by the image, even if not explicitly added with dagger.`),
dagql.Func("withServiceBinding", s.withServiceBinding).
Doc(`Establish a runtime dependency on a service.`,
`The service will be started automatically when needed and detached
when it is no longer needed, executing the default command if none is
set.`,
`The service will be reachable from the container via the provided hostname alias.`,
`The service dependency will also convey to any files or directories produced by the container.`).
ArgDoc("alias", `A name that can be used to reach the service from the container`).
ArgDoc("service", `Identifier of the service container`),
dagql.Func("withFocus", s.withFocus).
Doc(`Indicate that subsequent operations should be featured more prominently in the UI.`),
dagql.Func("withoutFocus", s.withoutFocus).
Doc(`Indicate that subsequent operations should not be featured more prominently in the UI.`,
`This is the initial state of all containers.`),
dagql.Func("withDefaultTerminalCmd", s.withDefaultTerminalCmd).
Doc(`Set the default command to invoke for the container's terminal API.`).
ArgDoc("args", `The args of the command.`).
ArgDoc("experimentalPrivilegedNesting",
`Provides Dagger access to the executed command.`,
`Do not use this option unless you trust the command being executed;
the command being executed WILL BE GRANTED FULL ACCESS TO YOUR HOST
FILESYSTEM.`).
ArgDoc("insecureRootCapabilities",
`Execute the command with all root capabilities. This is similar to
running a command with "sudo" or executing "docker run" with the
"--privileged" flag. Containerization does not provide any security
guarantees when using this option. It should only be used when
absolutely necessary and only with trusted commands.`),
dagql.NodeFunc("terminal", s.terminal).
Doc(`Return an interactive terminal for this container using its configured default terminal command if not overridden by args (or sh as a fallback default).`).
ArgDoc("cmd", `If set, override the container's default terminal command and invoke these command arguments instead.`).
ArgDoc("experimentalPrivilegedNesting",
`Provides Dagger access to the executed command.`,
`Do not use this option unless you trust the command being executed;
the command being executed WILL BE GRANTED FULL ACCESS TO YOUR HOST
FILESYSTEM.`).
ArgDoc("insecureRootCapabilities",
`Execute the command with all root capabilities. This is similar to
running a command with "sudo" or executing "docker run" with the
"--privileged" flag. Containerization does not provide any security
guarantees when using this option. It should only be used when
absolutely necessary and only with trusted commands.`),
dagql.Func("experimentalWithGPU", s.withGPU).
Doc(`EXPERIMENTAL API! Subject to change/removal at any time.`,
`Configures the provided list of devices to be accesible to this container.`,
`This currently works for Nvidia devices only.`).
ArgDoc("devices", `List of devices to be accessible to this container.`),
dagql.Func("experimentalWithAllGPUs", s.withAllGPUs).
Doc(`EXPERIMENTAL API! Subject to change/removal at any time.`,
`Configures all available GPUs on the host to be accessible to this container.`,
`This currently works for Nvidia devices only.`),
}.Install(s.srv)
dagql.Fields[*core.Terminal]{
dagql.Func("websocketEndpoint", s.shellWebsocketEndpoint).
Doc(`An http endpoint at which this terminal can be connected to over a websocket.`),
}.Install(s.srv)
}
type containerArgs struct {
ID dagql.Optional[core.ContainerID]
Platform dagql.Optional[core.Platform]
}
func (s *containerSchema) container(ctx context.Context, parent *core.Query, args containerArgs) (_ *core.Container, rerr error) {
if args.ID.Valid {
inst, err := args.ID.Value.Load(ctx, s.srv)
if err != nil {
return nil, err
}
// NB: what we kind of want is to return an Instance[*core.Container] in
// this case, but this API is deprecated anyhow
return inst.Self, nil
}
var platform core.Platform
if args.Platform.Valid {
platform = args.Platform.Value
} else {
platform = parent.Platform
}
return parent.NewContainer(platform), nil
}
type containerFromArgs struct {
Address string
}
func (s *containerSchema) from(ctx context.Context, parent *core.Container, args containerFromArgs) (*core.Container, error) {
return parent.From(ctx, args.Address)
}
type containerBuildArgs struct {
Context core.DirectoryID
Dockerfile string `default:"Dockerfile"`
Target string `default:""`
BuildArgs []dagql.InputObject[core.BuildArg] `default:"[]"`
Secrets []core.SecretID `default:"[]"`
}
func (s *containerSchema) build(ctx context.Context, parent *core.Container, args containerBuildArgs) (*core.Container, error) {
dir, err := args.Context.Load(ctx, s.srv)
if err != nil {
return nil, err
}
secrets, err := dagql.LoadIDs(ctx, s.srv, args.Secrets)
if err != nil {
return nil, err
}
return parent.Build(
ctx,
dir.Self,
args.Dockerfile,
collectInputsSlice(args.BuildArgs),
args.Target,
secrets,
)
}
type containerWithRootFSArgs struct {
Directory core.DirectoryID
}
func (s *containerSchema) withRootfs(ctx context.Context, parent *core.Container, args containerWithRootFSArgs) (*core.Container, error) {
dir, err := args.Directory.Load(ctx, s.srv)
if err != nil {
return nil, err
}
return parent.WithRootFS(ctx, dir.Self)
}
type containerPipelineArgs struct {
Name string
Description string `default:""`
Labels []dagql.InputObject[pipeline.Label] `default:"[]"`
}
func (s *containerSchema) pipeline(ctx context.Context, parent *core.Container, args containerPipelineArgs) (*core.Container, error) {
return parent.WithPipeline(ctx, args.Name, args.Description, collectInputsSlice(args.Labels))
}
func (s *containerSchema) rootfs(ctx context.Context, parent *core.Container, args struct{}) (*core.Directory, error) {
return parent.RootFS(ctx)
}
type containerExecArgs struct {
core.ContainerExecOpts
}
func (s *containerSchema) withExec(ctx context.Context, parent *core.Container, args containerExecArgs) (*core.Container, error) {
return parent.WithExec(ctx, args.ContainerExecOpts)
}
func (s *containerSchema) stdout(ctx context.Context, parent *core.Container, _ struct{}) (string, error) {
return parent.MetaFileContents(ctx, "stdout")
}
func (s *containerSchema) stderr(ctx context.Context, parent *core.Container, _ struct{}) (string, error) {
return parent.MetaFileContents(ctx, "stderr")
}
type containerGpuArgs struct {
core.ContainerGPUOpts
}
func (s *containerSchema) withGPU(ctx context.Context, parent *core.Container, args containerGpuArgs) (*core.Container, error) {
return parent.WithGPU(ctx, args.ContainerGPUOpts)
}
func (s *containerSchema) withAllGPUs(ctx context.Context, parent *core.Container, args struct{}) (*core.Container, error) {
return parent.WithGPU(ctx, core.ContainerGPUOpts{Devices: []string{"all"}})
}
type containerWithEntrypointArgs struct {
Args []string
KeepDefaultArgs bool `default:"false"`
}
func (s *containerSchema) withEntrypoint(ctx context.Context, parent *core.Container, args containerWithEntrypointArgs) (*core.Container, error) {
return parent.UpdateImageConfig(ctx, func(cfg specs.ImageConfig) specs.ImageConfig {
cfg.Entrypoint = args.Args
if !args.KeepDefaultArgs {
cfg.Cmd = nil
}
return cfg
})
}
type containerWithoutEntrypointArgs struct {
KeepDefaultArgs bool `default:"false"`
}
func (s *containerSchema) withoutEntrypoint(ctx context.Context, parent *core.Container, args containerWithoutEntrypointArgs) (*core.Container, error) {
return parent.UpdateImageConfig(ctx, func(cfg specs.ImageConfig) specs.ImageConfig {
cfg.Entrypoint = nil
if !args.KeepDefaultArgs {
cfg.Cmd = nil
}
return cfg
})
}
func (s *containerSchema) entrypoint(ctx context.Context, parent *core.Container, args struct{}) ([]string, error) {
cfg, err := parent.ImageConfig(ctx)
if err != nil {
return nil, err
}
return cfg.Entrypoint, nil
}
type containerWithDefaultArgs struct {
Args []string
}
func (s *containerSchema) withDefaultArgs(ctx context.Context, parent *core.Container, args containerWithDefaultArgs) (*core.Container, error) {
return parent.UpdateImageConfig(ctx, func(cfg specs.ImageConfig) specs.ImageConfig {
if args.Args == nil {
cfg.Cmd = []string{}
return cfg
}
cfg.Cmd = args.Args
return cfg
})
}
func (s *containerSchema) withoutDefaultArgs(ctx context.Context, parent *core.Container, _ struct{}) (*core.Container, error) {
return parent.UpdateImageConfig(ctx, func(cfg specs.ImageConfig) specs.ImageConfig {
cfg.Cmd = nil
return cfg
})
}
func (s *containerSchema) defaultArgs(ctx context.Context, parent *core.Container, args struct{}) ([]string, error) {
cfg, err := parent.ImageConfig(ctx)
if err != nil {
return nil, err
}
return cfg.Cmd, nil
}
type containerWithUserArgs struct {
Name string
}
func (s *containerSchema) withUser(ctx context.Context, parent *core.Container, args containerWithUserArgs) (*core.Container, error) {
return parent.UpdateImageConfig(ctx, func(cfg specs.ImageConfig) specs.ImageConfig {
cfg.User = args.Name
return cfg
})
}
func (s *containerSchema) withoutUser(ctx context.Context, parent *core.Container, _ struct{}) (*core.Container, error) {
return parent.UpdateImageConfig(ctx, func(cfg specs.ImageConfig) specs.ImageConfig {
cfg.User = ""
return cfg
})
}
func (s *containerSchema) user(ctx context.Context, parent *core.Container, args struct{}) (string, error) {
cfg, err := parent.ImageConfig(ctx)
if err != nil {
return "", err
}
return cfg.User, nil
}
type containerWithWorkdirArgs struct {
Path string
}
func (s *containerSchema) withWorkdir(ctx context.Context, parent *core.Container, args containerWithWorkdirArgs) (*core.Container, error) {
return parent.UpdateImageConfig(ctx, func(cfg specs.ImageConfig) specs.ImageConfig {
cfg.WorkingDir = absPath(cfg.WorkingDir, args.Path)
return cfg
})
}
func (s *containerSchema) withoutWorkdir(ctx context.Context, parent *core.Container, _ struct{}) (*core.Container, error) {
return parent.UpdateImageConfig(ctx, func(cfg specs.ImageConfig) specs.ImageConfig {
cfg.WorkingDir = ""
return cfg
})
}
func (s *containerSchema) workdir(ctx context.Context, parent *core.Container, args struct{}) (string, error) {
cfg, err := parent.ImageConfig(ctx)
if err != nil {
return "", err
}
return cfg.WorkingDir, nil
}
type containerWithVariableArgs struct {
Name string
Value string
Expand bool `default:"false"`
}
func (s *containerSchema) withEnvVariable(ctx context.Context, parent *core.Container, args containerWithVariableArgs) (*core.Container, error) {
return parent.UpdateImageConfig(ctx, func(cfg specs.ImageConfig) specs.ImageConfig {
value := args.Value
if args.Expand {
value = os.Expand(value, func(k string) string {
v, _ := core.LookupEnv(cfg.Env, k)
return v
})
}
cfg.Env = core.AddEnv(cfg.Env, args.Name, value)
return cfg
})
}
type containerWithoutVariableArgs struct {
Name string
}
func (s *containerSchema) withoutEnvVariable(ctx context.Context, parent *core.Container, args containerWithoutVariableArgs) (*core.Container, error) {
return parent.UpdateImageConfig(ctx, func(cfg specs.ImageConfig) specs.ImageConfig {
newEnv := []string{}
core.WalkEnv(cfg.Env, func(k, _, env string) {
if !shell.EqualEnvKeys(k, args.Name) {
newEnv = append(newEnv, env)
}
})
cfg.Env = newEnv
return cfg
})
}
type EnvVariable struct {
Name string `field:"true" doc:"The environment variable name."`
Value string `field:"true" doc:"The environment variable value."`
}
func (EnvVariable) Type() *ast.Type {
return &ast.Type{
NamedType: "EnvVariable",
NonNull: true,
}
}
func (EnvVariable) TypeDescription() string {
return "An environment variable name and value."
}
func (EnvVariable) Description() string {
return "A simple key value object that represents an environment variable."
}
func (s *containerSchema) envVariables(ctx context.Context, parent *core.Container, args struct{}) ([]EnvVariable, error) {
cfg, err := parent.ImageConfig(ctx)
if err != nil {
return nil, err
}
vars := make([]EnvVariable, 0, len(cfg.Env))
core.WalkEnv(cfg.Env, func(k, v, _ string) {
vars = append(vars, EnvVariable{Name: k, Value: v})
})
return vars, nil
}
type containerVariableArgs struct {
Name string
}
func (s *containerSchema) envVariable(ctx context.Context, parent *core.Container, args containerVariableArgs) (dagql.Nullable[dagql.String], error) {
none := dagql.Null[dagql.String]()
cfg, err := parent.ImageConfig(ctx)
if err != nil {
return none, err
}
if val, ok := core.LookupEnv(cfg.Env, args.Name); ok {
return dagql.NonNull(dagql.NewString(val)), nil
}
return none, nil
}
type Label struct {
Name string `field:"true" doc:"The label name."`
Value string `field:"true" doc:"The label value."`
}
func (Label) Type() *ast.Type {
return &ast.Type{
NamedType: "Label",
NonNull: true,
}
}
func (Label) TypeDescription() string {
return "A simple key value object that represents a label."
}
func (s *containerSchema) labels(ctx context.Context, parent *core.Container, args struct{}) ([]Label, error) {
cfg, err := parent.ImageConfig(ctx)
if err != nil {
return nil, err
}
labels := make([]Label, 0, len(cfg.Labels))
for name, value := range cfg.Labels {
label := Label{
Name: name,
Value: value,
}
labels = append(labels, label)
}
// FIXME(vito): sort, test; order must be stable for IDs to work as expected
return labels, nil
}
type containerLabelArgs struct {
Name string
}
func (s *containerSchema) label(ctx context.Context, parent *core.Container, args containerLabelArgs) (dagql.Nullable[dagql.String], error) {
none := dagql.Null[dagql.String]()
cfg, err := parent.ImageConfig(ctx)
if err != nil {
return none, err
}
if val, ok := cfg.Labels[args.Name]; ok {
return dagql.NonNull(dagql.NewString(val)), nil
}
return none, nil
}
type containerWithMountedDirectoryArgs struct {
Path string
Source core.DirectoryID
Owner string `default:""`
}
func (s *containerSchema) withMountedDirectory(ctx context.Context, parent *core.Container, args containerWithMountedDirectoryArgs) (*core.Container, error) {
dir, err := args.Source.Load(ctx, s.srv)
if err != nil {
return nil, err
}
return parent.WithMountedDirectory(ctx, args.Path, dir.Self, args.Owner, false)
}
type containerPublishArgs struct {
Address dagql.String
PlatformVariants []core.ContainerID `default:"[]"`
ForcedCompression dagql.Optional[core.ImageLayerCompression]
MediaTypes core.ImageMediaTypes `default:"OCIMediaTypes"`
}
func (s *containerSchema) publish(ctx context.Context, parent *core.Container, args containerPublishArgs) (dagql.String, error) {
variants, err := dagql.LoadIDs(ctx, s.srv, args.PlatformVariants)
if err != nil {
return "", err
}
ref, err := parent.Publish(
ctx,
args.Address.String(),
variants,
args.ForcedCompression.Value,
args.MediaTypes,
)
if err != nil {
return "", err
}
return dagql.NewString(ref), nil
}
type containerWithMountedFileArgs struct {
Path string
Source core.FileID
Owner string `default:""`
}
func (s *containerSchema) withMountedFile(ctx context.Context, parent *core.Container, args containerWithMountedFileArgs) (*core.Container, error) {
file, err := args.Source.Load(ctx, s.srv)
if err != nil {
return nil, err
}
return parent.WithMountedFile(ctx, args.Path, file.Self, args.Owner, false)
}
type containerWithMountedCacheArgs struct {
Path string
Cache core.CacheVolumeID
Source dagql.Optional[core.DirectoryID]
Sharing core.CacheSharingMode `default:"SHARED"`
Owner string `default:""`
}
func (s *containerSchema) withMountedCache(ctx context.Context, parent *core.Container, args containerWithMountedCacheArgs) (*core.Container, error) {
var dir *core.Directory
if args.Source.Valid {
inst, err := args.Source.Value.Load(ctx, s.srv)
if err != nil {
return nil, err
}
dir = inst.Self
}
cache, err := args.Cache.Load(ctx, s.srv)
if err != nil {
return nil, err
}
return parent.WithMountedCache(
ctx,
args.Path,
cache.Self,
dir,
args.Sharing,
args.Owner,
)
}
type containerWithMountedTempArgs struct {
Path string
}
func (s *containerSchema) withMountedTemp(ctx context.Context, parent *core.Container, args containerWithMountedTempArgs) (*core.Container, error) {
return parent.WithMountedTemp(ctx, args.Path)
}
type containerWithoutMountArgs struct {
Path string
}
func (s *containerSchema) withoutMount(ctx context.Context, parent *core.Container, args containerWithoutMountArgs) (*core.Container, error) {
return parent.WithoutMount(ctx, args.Path)
}
func (s *containerSchema) mounts(ctx context.Context, parent *core.Container, _ struct{}) (dagql.Array[dagql.String], error) {
targets, err := parent.MountTargets(ctx)
if err != nil {
return nil, err
}
return dagql.NewStringArray(targets...), nil
}
type containerWithLabelArgs struct {
Name string
Value string
}
func (s *containerSchema) withLabel(ctx context.Context, parent *core.Container, args containerWithLabelArgs) (*core.Container, error) {
return parent.UpdateImageConfig(ctx, func(cfg specs.ImageConfig) specs.ImageConfig {
if cfg.Labels == nil {
cfg.Labels = make(map[string]string)
}
cfg.Labels[args.Name] = args.Value
return cfg
})
}
type containerWithoutLabelArgs struct {
Name string
}
func (s *containerSchema) withoutLabel(ctx context.Context, parent *core.Container, args containerWithoutLabelArgs) (*core.Container, error) {
return parent.UpdateImageConfig(ctx, func(cfg specs.ImageConfig) specs.ImageConfig {
delete(cfg.Labels, args.Name)
return cfg
})
}
type containerDirectoryArgs struct {
Path string
}
func (s *containerSchema) directory(ctx context.Context, parent *core.Container, args containerDirectoryArgs) (*core.Directory, error) {
return parent.Directory(ctx, args.Path)
}
type containerFileArgs struct {
Path string
}
func (s *containerSchema) file(ctx context.Context, parent *core.Container, args containerFileArgs) (*core.File, error) {
return parent.File(ctx, args.Path)
}
func absPath(workDir string, containerPath string) string {
if path.IsAbs(containerPath) {
return containerPath
}
if workDir == "" {
workDir = "/"
}
return path.Join(workDir, containerPath)
}
type containerWithSecretVariableArgs struct {
Name string
Secret core.SecretID
}
func (s *containerSchema) withSecretVariable(ctx context.Context, parent *core.Container, args containerWithSecretVariableArgs) (*core.Container, error) {
secret, err := args.Secret.Load(ctx, s.srv)
if err != nil {
return nil, err
}
return parent.WithSecretVariable(ctx, args.Name, secret.Self)
}
type containerWithMountedSecretArgs struct {
Path string
Source core.SecretID
Owner string `default:""`
Mode int `default:"0400"` // FIXME(vito): verify octal
}
func (s *containerSchema) withMountedSecret(ctx context.Context, parent *core.Container, args containerWithMountedSecretArgs) (*core.Container, error) {
secret, err := args.Source.Load(ctx, s.srv)
if err != nil {
return nil, err
}
return parent.WithMountedSecret(ctx, args.Path, secret.Self, args.Owner, fs.FileMode(args.Mode))
}
type containerWithDirectoryArgs struct {
WithDirectoryArgs
Owner string `default:""`
}
func (s *containerSchema) withDirectory(ctx context.Context, parent *core.Container, args containerWithDirectoryArgs) (*core.Container, error) {
dir, err := args.Directory.Load(ctx, s.srv)
if err != nil {
return nil, err
}
return parent.WithDirectory(ctx, args.Path, dir.Self, args.CopyFilter, args.Owner)
}
type containerWithFileArgs struct {
WithFileArgs
Owner string `default:""`
}
func (s *containerSchema) withFile(ctx context.Context, parent *core.Container, args containerWithFileArgs) (*core.Container, error) {
file, err := args.Source.Load(ctx, s.srv)
if err != nil {
return nil, err
}
return parent.WithFile(ctx, args.Path, file.Self, args.Permissions, args.Owner)
}
type containerWithFilesArgs struct {
WithFilesArgs
Owner string `default:""`
}
func (s *containerSchema) withFiles(ctx context.Context, parent *core.Container, args containerWithFilesArgs) (*core.Container, error) {
files := []*core.File{}
for _, id := range args.Sources {
file, err := id.Load(ctx, s.srv)
if err != nil {
return nil, err
}
files = append(files, file.Self)
}
return parent.WithFiles(ctx, args.Path, files, args.Permissions, args.Owner)
}
type containerWithNewFileArgs struct {
Path string
Contents string `default:""`
Permissions int `default:"0644"`
Owner string `default:""`
}
func (s *containerSchema) withNewFile(ctx context.Context, parent *core.Container, args containerWithNewFileArgs) (*core.Container, error) {
return parent.WithNewFile(ctx, args.Path, []byte(args.Contents), fs.FileMode(args.Permissions), args.Owner)
}
type containerWithUnixSocketArgs struct {
Path string
Source core.SocketID
Owner string `default:""`
}
func (s *containerSchema) withUnixSocket(ctx context.Context, parent *core.Container, args containerWithUnixSocketArgs) (*core.Container, error) {
socket, err := args.Source.Load(ctx, s.srv)
if err != nil {
return nil, err
}
return parent.WithUnixSocket(ctx, args.Path, socket.Self, args.Owner)
}
type containerWithoutUnixSocketArgs struct {
Path string
}
func (s *containerSchema) withoutUnixSocket(ctx context.Context, parent *core.Container, args containerWithoutUnixSocketArgs) (*core.Container, error) {
return parent.WithoutUnixSocket(ctx, args.Path)
}
func (s *containerSchema) platform(ctx context.Context, parent *core.Container, args struct{}) (core.Platform, error) {
return parent.Platform, nil
}
type containerExportArgs struct {
Path string
PlatformVariants []core.ContainerID `default:"[]"`
ForcedCompression dagql.Optional[core.ImageLayerCompression]
MediaTypes core.ImageMediaTypes `default:"OCIMediaTypes"`
}
func (s *containerSchema) export(ctx context.Context, parent *core.Container, args containerExportArgs) (dagql.Boolean, error) {
variants, err := dagql.LoadIDs(ctx, s.srv, args.PlatformVariants)
if err != nil {
return false, err
}
if err := parent.Export(
ctx,
args.Path,
variants,
args.ForcedCompression.Value,
args.MediaTypes,
); err != nil {
return false, err
}
return true, nil
}
type containerAsTarballArgs struct {
PlatformVariants []core.ContainerID `default:"[]"`
ForcedCompression dagql.Optional[core.ImageLayerCompression]
MediaTypes core.ImageMediaTypes `default:"OCIMediaTypes"`
}
func (s *containerSchema) asTarball(ctx context.Context, parent *core.Container, args containerAsTarballArgs) (*core.File, error) {
variants, err := dagql.LoadIDs(ctx, s.srv, args.PlatformVariants)
if err != nil {
return nil, err
}
return parent.AsTarball(ctx, variants, args.ForcedCompression.Value, args.MediaTypes)
}
type containerImportArgs struct {
Source core.FileID
Tag string `default:""`
}
func (s *containerSchema) import_(ctx context.Context, parent *core.Container, args containerImportArgs) (*core.Container, error) {
start := time.Now()
slog.Debug("importing container", "source", args.Source.Display(), "tag", args.Tag)
defer func() {
slog.Debug("done importing container", "source", args.Source.Display(), "tag", args.Tag, "took", start)
}()
source, err := args.Source.Load(ctx, s.srv)
if err != nil {
return nil, err
}
return parent.Import(
ctx,
source.Self,
args.Tag,
)
}
type containerWithRegistryAuthArgs struct {
Address string
Username string
Secret core.SecretID
}
func (s *containerSchema) withRegistryAuth(ctx context.Context, parent *core.Container, args containerWithRegistryAuthArgs) (*core.Container, error) {
secret, err := args.Secret.Load(ctx, s.srv)
if err != nil {
return nil, err
}
secretBytes, err := parent.Query.Secrets.GetSecret(ctx, secret.Self.Accessor)
if err != nil {
return nil, err
}
if err := parent.Query.Auth.AddCredential(args.Address, args.Username, string(secretBytes)); err != nil {
return nil, err
}
return parent, nil
}
type containerWithoutRegistryAuthArgs struct {
Address string
}
func (s *containerSchema) withoutRegistryAuth(_ context.Context, parent *core.Container, args containerWithoutRegistryAuthArgs) (*core.Container, error) {
if err := parent.Query.Auth.RemoveCredential(args.Address); err != nil {
return nil, err
}
return parent, nil
}
func (s *containerSchema) imageRef(ctx context.Context, parent *core.Container, args struct{}) (string, error) {
return parent.ImageRefOrErr(ctx)
}
type containerWithServiceBindingArgs struct {
Alias string
Service core.ServiceID
}
func (s *containerSchema) withServiceBinding(ctx context.Context, parent *core.Container, args containerWithServiceBindingArgs) (*core.Container, error) {
svc, err := args.Service.Load(ctx, s.srv)
if err != nil {
return nil, err
}
return parent.WithServiceBinding(ctx, svc.ID(), svc.Self, args.Alias)
}
type containerWithExposedPortArgs struct {
Port int
Protocol core.NetworkProtocol `default:"TCP"`
Description *string
ExperimentalSkipHealthcheck bool `default:"false"`
}
func (s *containerSchema) withExposedPort(ctx context.Context, parent *core.Container, args containerWithExposedPortArgs) (*core.Container, error) {
return parent.WithExposedPort(core.Port{
Protocol: args.Protocol,
Port: args.Port,
Description: args.Description,
ExperimentalSkipHealthcheck: args.ExperimentalSkipHealthcheck,
})
}
type containerWithoutExposedPortArgs struct {
Port int
Protocol core.NetworkProtocol `default:"TCP"`
}
func (s *containerSchema) withoutExposedPort(ctx context.Context, parent *core.Container, args containerWithoutExposedPortArgs) (*core.Container, error) {
return parent.WithoutExposedPort(args.Port, args.Protocol)
}
func (s *containerSchema) exposedPorts(ctx context.Context, parent *core.Container, args struct{}) ([]core.Port, error) {
// get descriptions from `Container.Ports` (not in the OCI spec)
ports := make(map[string]core.Port, len(parent.Ports))
for _, p := range parent.Ports {
ociPort := fmt.Sprintf("%d/%s", p.Port, p.Protocol.Network())
ports[ociPort] = p
}
exposedPorts := []core.Port{}
for ociPort := range parent.Config.ExposedPorts {
p, exists := ports[ociPort]
if !exists {
// ignore errors when parsing from OCI
port, protoStr, ok := strings.Cut(ociPort, "/")
if !ok {
continue
}
portNr, err := strconv.Atoi(port)
if err != nil {
continue
}
proto, err := core.NetworkProtocols.Lookup(strings.ToUpper(protoStr))
if err != nil {
// FIXME(vito): should this and above return nil, err instead?
continue
}
p = core.Port{
Port: portNr,
Protocol: proto,
}
}
exposedPorts = append(exposedPorts, p)
}
return exposedPorts, nil
}
func (s *containerSchema) withFocus(ctx context.Context, parent *core.Container, args struct{}) (*core.Container, error) {
child := parent.Clone()
child.Focused = true
return child, nil
}
func (s *containerSchema) withoutFocus(ctx context.Context, parent *core.Container, args struct{}) (*core.Container, error) {
child := parent.Clone()
child.Focused = false
return child, nil
}
type containerWithDefaultTerminalCmdArgs struct {
core.DefaultTerminalCmdOpts
}
func (s *containerSchema) withDefaultTerminalCmd(
ctx context.Context,
ctr *core.Container,
args containerWithDefaultTerminalCmdArgs,
) (*core.Container, error) {
ctr = ctr.Clone()
ctr.DefaultTerminalCmd = &args.DefaultTerminalCmdOpts
return ctr, nil
}
type containerTerminalArgs struct {
core.TerminalArgs
}
func (s *containerSchema) terminal(
ctx context.Context,
ctr dagql.Instance[*core.Container],
args containerTerminalArgs,
) (*core.Terminal, error) {
if args.Cmd == nil || len(args.Cmd) == 0 {
args.Cmd = ctr.Self.DefaultTerminalCmd.Args
}
if args.ExperimentalPrivilegedNesting == nil {
args.ExperimentalPrivilegedNesting = &ctr.Self.DefaultTerminalCmd.ExperimentalPrivilegedNesting
}
if args.InsecureRootCapabilities == nil {
args.InsecureRootCapabilities = &ctr.Self.DefaultTerminalCmd.InsecureRootCapabilities
}
// if still no args, default to sh
if len(args.Cmd) == 0 {
args.Cmd = []string{"sh"}
}
term, handler, err := ctr.Self.Terminal(ctr.ID(), &args.TerminalArgs)
if err != nil {
return nil, err
}
if err := ctr.Self.Query.MuxEndpoint(ctx, path.Join("/", term.Endpoint), handler); err != nil {
return nil, err
}
return term, nil
}
func (s *containerSchema) shellWebsocketEndpoint(ctx context.Context, parent *core.Terminal, args struct{}) (string, error) {
return parent.WebsocketURL(), nil
}
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,687 | 🐞 Directory.glob with recursive patterns (`**/*.go`) returns duplicates and is very slow | ### What is the issue?
It looks like Buildkit returns weird results when you `ReadDir` with a glob like `**/*.go`. It actually seems to find everything recursively, but then trim each result to only have the first path segment. So for `a/1.go a/2.go b/3.go` it'll return `a a b`. We then recurse into `a` twice, which will also have this issue, so it quickly explodes into a huge number of results.
We could work around this issue by deduping, but it would probably be better to fix this upstream in Buildkit. It would be perfect if it just returned all the full paths, which it *seems* capable of doing. Then we wouldn't need to recurse ourselves. While we're there, maybe we could add support for exclude filters too (edit: interestingly it seems to support `!` prefixes for exclusions - maybe we should be phasing out `include: ["a"], exclude: ["b"]` in favor of `globs: ["a", "!b"]`?).
cc @jedevc @TomChv for continuity from [https://github.com/dagger/dagger/pull/5824#discussion_r1350193214](https://github.com/dagger/dagger/pull/5824#discussion_r1350193214)
### Dagger version
v0.9.1+ (when the feature was added; not a regression)
### Steps to reproduce
```graphql
{
git(url:"https://github.com/dagger/dagger") {
branch(name:"main"){
tree {
glob(pattern:"**/dagger.json")
}
}
}
}
```
### Log output
```json
{
"data": {
"git": {
"branch": {
"tree": {
"glob": [
"ci/dagger.json",
"core/integration/testdata/modules/go/basic/dagger.json",
"core/integration/testdata/modules/go/broken/dagger.json",
"core/integration/testdata/modules/go/ifaces/dagger.json",
"core/integration/testdata/modules/go/ifaces/impl/dagger.json",
"core/integration/testdata/modules/go/ifaces/test/dagger.json",
"core/integration/testdata/modules/go/namespacing/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub1/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub2/dagger.json",
"core/integration/testdata/modules/go/basic/dagger.json",
"core/integration/testdata/modules/go/broken/dagger.json",
"core/integration/testdata/modules/go/ifaces/dagger.json",
"core/integration/testdata/modules/go/ifaces/impl/dagger.json",
"core/integration/testdata/modules/go/ifaces/test/dagger.json",
"core/integration/testdata/modules/go/namespacing/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub1/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub2/dagger.json",
"core/integration/testdata/modules/go/basic/dagger.json",
"core/integration/testdata/modules/go/broken/dagger.json",
"core/integration/testdata/modules/go/ifaces/dagger.json",
"core/integration/testdata/modules/go/ifaces/impl/dagger.json",
"core/integration/testdata/modules/go/ifaces/test/dagger.json",
"core/integration/testdata/modules/go/namespacing/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub1/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub2/dagger.json",
// you get the idea
``` | https://github.com/dagger/dagger/issues/6687 | https://github.com/dagger/dagger/pull/6852 | 0d815c84455006adb0187f6aa144bfe1356a35cc | 49863fb3638be2bfc351fc8db3d5b1a4fc5668e7 | "2024-02-18T01:09:37Z" | go | "2024-03-07T16:43:26Z" | .changes/unreleased/Fixed-20240307-145421.yaml | |
closed | dagger/dagger | https://github.com/dagger/dagger | 6,687 | 🐞 Directory.glob with recursive patterns (`**/*.go`) returns duplicates and is very slow | ### What is the issue?
It looks like Buildkit returns weird results when you `ReadDir` with a glob like `**/*.go`. It actually seems to find everything recursively, but then trim each result to only have the first path segment. So for `a/1.go a/2.go b/3.go` it'll return `a a b`. We then recurse into `a` twice, which will also have this issue, so it quickly explodes into a huge number of results.
We could work around this issue by deduping, but it would probably be better to fix this upstream in Buildkit. It would be perfect if it just returned all the full paths, which it *seems* capable of doing. Then we wouldn't need to recurse ourselves. While we're there, maybe we could add support for exclude filters too (edit: interestingly it seems to support `!` prefixes for exclusions - maybe we should be phasing out `include: ["a"], exclude: ["b"]` in favor of `globs: ["a", "!b"]`?).
cc @jedevc @TomChv for continuity from [https://github.com/dagger/dagger/pull/5824#discussion_r1350193214](https://github.com/dagger/dagger/pull/5824#discussion_r1350193214)
### Dagger version
v0.9.1+ (when the feature was added; not a regression)
### Steps to reproduce
```graphql
{
git(url:"https://github.com/dagger/dagger") {
branch(name:"main"){
tree {
glob(pattern:"**/dagger.json")
}
}
}
}
```
### Log output
```json
{
"data": {
"git": {
"branch": {
"tree": {
"glob": [
"ci/dagger.json",
"core/integration/testdata/modules/go/basic/dagger.json",
"core/integration/testdata/modules/go/broken/dagger.json",
"core/integration/testdata/modules/go/ifaces/dagger.json",
"core/integration/testdata/modules/go/ifaces/impl/dagger.json",
"core/integration/testdata/modules/go/ifaces/test/dagger.json",
"core/integration/testdata/modules/go/namespacing/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub1/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub2/dagger.json",
"core/integration/testdata/modules/go/basic/dagger.json",
"core/integration/testdata/modules/go/broken/dagger.json",
"core/integration/testdata/modules/go/ifaces/dagger.json",
"core/integration/testdata/modules/go/ifaces/impl/dagger.json",
"core/integration/testdata/modules/go/ifaces/test/dagger.json",
"core/integration/testdata/modules/go/namespacing/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub1/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub2/dagger.json",
"core/integration/testdata/modules/go/basic/dagger.json",
"core/integration/testdata/modules/go/broken/dagger.json",
"core/integration/testdata/modules/go/ifaces/dagger.json",
"core/integration/testdata/modules/go/ifaces/impl/dagger.json",
"core/integration/testdata/modules/go/ifaces/test/dagger.json",
"core/integration/testdata/modules/go/namespacing/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub1/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub2/dagger.json",
// you get the idea
``` | https://github.com/dagger/dagger/issues/6687 | https://github.com/dagger/dagger/pull/6852 | 0d815c84455006adb0187f6aa144bfe1356a35cc | 49863fb3638be2bfc351fc8db3d5b1a4fc5668e7 | "2024-02-18T01:09:37Z" | go | "2024-03-07T16:43:26Z" | go.mod | module github.com/dagger/dagger
go 1.21
replace dagger.io/dagger => ./sdk/go
require (
dagger.io/dagger v0.10.0
github.com/99designs/gqlgen v0.17.41
github.com/Khan/genqlient v0.6.0
github.com/MakeNowJust/heredoc/v2 v2.0.1
github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2
github.com/a-h/templ v0.2.543
github.com/adrg/xdg v0.4.0
github.com/blang/semver v3.5.1+incompatible
github.com/cenkalti/backoff/v4 v4.2.1
github.com/charmbracelet/bubbles v0.18.0
github.com/charmbracelet/bubbletea v0.25.0
github.com/charmbracelet/lipgloss v0.9.1
github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81
github.com/containerd/containerd v1.7.12
github.com/containerd/continuity v0.4.3
github.com/containerd/fuse-overlayfs-snapshotter v1.0.6
github.com/containerd/stargz-snapshotter v0.15.1
github.com/containernetworking/cni v1.1.2
github.com/coreos/go-systemd/v22 v22.5.0
github.com/creack/pty v1.1.18
github.com/dave/jennifer v1.7.0
github.com/denisbrodbeck/machineid v1.0.1
github.com/docker/cli v25.0.1+incompatible
github.com/docker/distribution v2.8.2+incompatible
github.com/docker/docker v25.0.1+incompatible
github.com/dschmidt/go-layerfs v0.1.0
github.com/go-git/go-git/v5 v5.11.0
github.com/gofrs/flock v0.8.1
github.com/gogo/protobuf v1.3.2
github.com/google/go-containerregistry v0.19.0
github.com/google/go-github/v50 v50.2.0
github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510
github.com/google/uuid v1.6.0
github.com/gorilla/websocket v1.5.0
github.com/grpc-ecosystem/go-grpc-middleware v1.3.0
github.com/iancoleman/strcase v0.3.0
github.com/jackpal/gateway v1.0.7
github.com/juju/ansiterm v1.0.0
github.com/klauspost/compress v1.17.4
github.com/mackerelio/go-osstat v0.2.4
github.com/mattn/go-isatty v0.0.20
github.com/mitchellh/go-spdx v0.1.0
github.com/moby/buildkit v0.13.0-beta3 // https://github.com/moby/buildkit/commit/1981eb123dc979fc71d097adeb5bbb84110aa9f4
github.com/moby/locker v1.0.1
github.com/moby/patternmatcher v0.6.0
github.com/moby/sys/mount v0.3.3
github.com/muesli/reflow v0.3.0
github.com/muesli/termenv v0.15.2
github.com/nxadm/tail v1.4.8
github.com/opencontainers/go-digest v1.0.0
github.com/opencontainers/image-spec v1.1.0-rc5
github.com/opencontainers/runc v1.1.12
github.com/opencontainers/runtime-spec v1.1.0
github.com/pelletier/go-toml v1.9.5
github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8
github.com/pkg/errors v0.9.1
github.com/prometheus/procfs v0.12.0
github.com/psanford/memfs v0.0.0-20230130182539-4dbf7e3e865e
github.com/rs/cors v1.10.0
github.com/rs/zerolog v1.32.0
github.com/samber/slog-logrus/v2 v2.2.0
github.com/shurcooL/graphql v0.0.0-20220606043923-3cf50f8a0a29
github.com/sirupsen/logrus v1.9.3
github.com/sourcegraph/conc v0.3.0
github.com/spf13/cobra v1.8.0
github.com/spf13/pflag v1.0.5
github.com/stretchr/testify v1.9.0
github.com/tidwall/gjson v1.17.0
github.com/tonistiigi/fsutil v0.0.0-20230825212630-f09800878302
github.com/tonistiigi/units v0.0.0-20180711220420-6950e57a87ea
github.com/urfave/cli v1.22.14
github.com/vektah/gqlparser/v2 v2.5.10
github.com/vito/midterm v0.1.5-0.20240215023001-e649b2677bfa
github.com/vito/progrock v0.10.2-0.20240221152222-63c8df30db8d
github.com/weaveworks/common v0.0.0-20230119144549-0aaa5abd1e63
github.com/zeebo/xxh3 v1.0.2
go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.46.0
go.opentelemetry.io/otel v1.21.0
go.opentelemetry.io/otel/exporters/jaeger v1.17.0
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.21.0
go.opentelemetry.io/otel/sdk v1.21.0
go.opentelemetry.io/otel/trace v1.21.0
go.opentelemetry.io/proto/otlp v1.0.0
golang.org/x/crypto v0.20.0
golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa
golang.org/x/mod v0.14.0
golang.org/x/net v0.21.0
golang.org/x/oauth2 v0.17.0
golang.org/x/sync v0.6.0
golang.org/x/sys v0.17.0
golang.org/x/term v0.17.0
golang.org/x/text v0.14.0
golang.org/x/tools v0.17.0
google.golang.org/grpc v1.61.0
google.golang.org/protobuf v1.32.0
gopkg.in/yaml.v3 v3.0.1
gotest.tools/v3 v3.5.1
oss.terrastruct.com/d2 v0.6.1
oss.terrastruct.com/util-go v0.0.0-20231101220827-55b3812542c2
)
require (
cdr.dev/slog v1.4.2 // indirect
dario.cat/mergo v1.0.0 // indirect
github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24 // indirect
github.com/Azure/azure-sdk-for-go/sdk/azcore v1.1.0 // indirect
github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.1.0 // indirect
github.com/Azure/azure-sdk-for-go/sdk/internal v1.0.0 // indirect
github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v0.4.1 // indirect
github.com/AzureAD/microsoft-authentication-library-for-go v0.6.0 // indirect
github.com/Microsoft/go-winio v0.6.1 // indirect
github.com/Microsoft/hcsshim v0.11.4 // indirect
github.com/ProtonMail/go-crypto v0.0.0-20230828082145-3c4c8a2d2371 // indirect
github.com/PuerkitoBio/goquery v1.8.1 // indirect
github.com/agext/levenshtein v1.2.3 // indirect
github.com/agnivade/levenshtein v1.1.1 // indirect
github.com/alecthomas/chroma v0.10.0 // indirect
github.com/alecthomas/chroma/v2 v2.11.1 // indirect
github.com/anchore/go-struct-converter v0.0.0-20221118182256-c68fdcfa2092 // indirect
github.com/andybalholm/cascadia v1.3.2 // indirect
github.com/armon/circbuf v0.0.0-20190214190532-5111143e8da2 // indirect
github.com/aws/aws-sdk-go-v2 v1.24.1 // indirect
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.5.4 // indirect
github.com/aws/aws-sdk-go-v2/config v1.26.6 // indirect
github.com/aws/aws-sdk-go-v2/credentials v1.16.16 // indirect
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11 // indirect
github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.15.15 // indirect
github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 // indirect
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 // indirect
github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3 // indirect
github.com/aws/aws-sdk-go-v2/internal/v4a v1.2.10 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.2.10 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.16.10 // indirect
github.com/aws/aws-sdk-go-v2/service/s3 v1.48.1 // indirect
github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 // indirect
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 // indirect
github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 // indirect
github.com/aws/smithy-go v1.19.0 // indirect
github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
github.com/beorn7/perks v1.0.1 // indirect
github.com/cespare/xxhash/v2 v2.2.0 // indirect
github.com/charmbracelet/harmonica v0.2.0 // indirect
github.com/cloudflare/circl v1.3.7 // indirect
github.com/containerd/cgroups v1.1.0 // indirect
github.com/containerd/fifo v1.1.0 // indirect
github.com/containerd/go-cni v1.1.9 // indirect
github.com/containerd/go-runc v1.1.0 // indirect
github.com/containerd/log v0.1.0 // indirect
github.com/containerd/nydus-snapshotter v0.13.1 // indirect
github.com/containerd/stargz-snapshotter/estargz v0.15.1 // indirect
github.com/containerd/ttrpc v1.2.2 // indirect
github.com/containerd/typeurl/v2 v2.1.1 // indirect
github.com/containernetworking/plugins v1.4.0 // indirect
github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
github.com/cyphar/filepath-securejoin v0.2.4 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/dimchansky/utfbom v1.1.1 // indirect
github.com/distribution/reference v0.5.0 // indirect
github.com/dlclark/regexp2 v1.10.0 // indirect
github.com/docker/docker-credential-helpers v0.8.0 // indirect
github.com/docker/go-connections v0.5.0 // indirect
github.com/docker/go-metrics v0.0.1 // indirect
github.com/docker/go-units v0.5.0 // indirect
github.com/dop251/goja v0.0.0-20231027120936-b396bb4c349d // indirect
github.com/emirpasic/gods v1.18.1 // indirect
github.com/fatih/color v1.16.0 // indirect
github.com/felixge/httpsnoop v1.0.4 // indirect
github.com/fogleman/ease v0.0.0-20170301025033-8da417bf1776 // indirect
github.com/fsnotify/fsnotify v1.7.0 // indirect
github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
github.com/go-git/go-billy/v5 v5.5.0 // indirect
github.com/go-kit/log v0.2.1 // indirect
github.com/go-logfmt/logfmt v0.5.1 // indirect
github.com/go-logr/logr v1.3.0 // indirect
github.com/go-logr/stdr v1.2.2 // indirect
github.com/go-sourcemap/sourcemap v2.1.3+incompatible // indirect
github.com/gogo/googleapis v1.4.1 // indirect
github.com/golang-jwt/jwt/v4 v4.4.2 // indirect
github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
github.com/golang/protobuf v1.5.3 // indirect
github.com/google/go-cmp v0.6.0 // indirect
github.com/google/go-querystring v1.1.0 // indirect
github.com/google/pprof v0.0.0-20231101202521-4ca4178f5c7a // indirect
github.com/grpc-ecosystem/grpc-gateway/v2 v2.18.1 // indirect
github.com/hanwen/go-fuse/v2 v2.4.0 // indirect
github.com/hashicorp/errwrap v1.1.0 // indirect
github.com/hashicorp/go-cleanhttp v0.5.2 // indirect
github.com/hashicorp/go-immutable-radix v1.3.1 // indirect
github.com/hashicorp/go-multierror v1.1.1 // indirect
github.com/hashicorp/go-retryablehttp v0.7.4 // indirect
github.com/hashicorp/golang-lru v0.5.4 // indirect
github.com/hashicorp/golang-lru/v2 v2.0.3 // indirect
github.com/in-toto/in-toto-golang v0.5.0 // indirect
github.com/inconshreveable/mousetrap v1.1.0 // indirect
github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
github.com/jmespath/go-jmespath v0.4.0 // indirect
github.com/jonboulle/clockwork v0.4.0 // indirect
github.com/kevinburke/ssh_config v1.2.0 // indirect
github.com/klauspost/cpuid/v2 v2.0.9 // indirect
github.com/kylelemons/godebug v1.1.0 // indirect
github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
github.com/lunixbochs/vtclean v1.0.0 // indirect
github.com/mattn/go-colorable v0.1.13 // indirect
github.com/mattn/go-localereader v0.0.1 // indirect
github.com/mattn/go-runewidth v0.0.15 // indirect
github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
github.com/mazznoer/csscolorparser v0.1.3 // indirect
github.com/mitchellh/go-homedir v1.1.0 // indirect
github.com/mitchellh/hashstructure/v2 v2.0.2 // indirect
github.com/mitchellh/mapstructure v1.5.0 // indirect
github.com/moby/sys/mountinfo v0.7.1 // indirect
github.com/moby/sys/sequential v0.5.0 // indirect
github.com/moby/sys/signal v0.7.0 // indirect
github.com/moby/sys/user v0.1.0 // indirect
github.com/morikuni/aec v1.0.0 // indirect
github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
github.com/muesli/cancelreader v0.2.2 // indirect
github.com/opencontainers/selinux v1.11.0 // indirect
github.com/package-url/packageurl-go v0.1.1-0.20220428063043-89078438f170 // indirect
github.com/pjbgf/sha1cd v0.3.0 // indirect
github.com/pkg/profile v1.5.0 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/prometheus/client_golang v1.17.0 // indirect
github.com/prometheus/client_model v0.4.1-0.20230718164431-9a2bf3000d16 // indirect
github.com/prometheus/common v0.44.0 // indirect
github.com/rivo/uniseg v0.4.6 // indirect
github.com/russross/blackfriday/v2 v2.1.0 // indirect
github.com/samber/lo v1.38.1 // indirect
github.com/samber/slog-common v0.14.0 // indirect
github.com/secure-systems-lab/go-securesystemslib v0.4.0 // indirect
github.com/sergi/go-diff v1.3.1 // indirect
github.com/shibumi/go-pathspec v1.3.0 // indirect
github.com/skeema/knownhosts v1.2.1 // indirect
github.com/sosodev/duration v1.1.0 // indirect
github.com/spdx/tools-golang v0.5.1 // indirect
github.com/tidwall/match v1.1.1 // indirect
github.com/tidwall/pretty v1.2.1 // indirect
github.com/tonistiigi/go-actions-cache v0.0.0-20220404170428-0bdeb6e1eac7 // indirect
github.com/tonistiigi/go-archvariant v1.0.0 // indirect
github.com/tonistiigi/vt100 v0.0.0-20230623042737-f9a4f7ef6531 // indirect
github.com/vbatts/tar-split v0.11.5 // indirect
github.com/vishvananda/netlink v1.2.1-beta.2 // indirect
github.com/vishvananda/netns v0.0.4 // indirect
github.com/weaveworks/promrus v1.2.0 // indirect
github.com/xanzy/ssh-agent v0.3.3 // indirect
github.com/yuin/goldmark v1.6.0 // indirect
github.com/zmb3/spotify/v2 v2.3.1 // indirect
go.etcd.io/bbolt v1.3.7 // indirect
go.opencensus.io v0.24.0 // indirect
go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.45.0 // indirect
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.45.0 // indirect
go.opentelemetry.io/otel/exporters/otlp/otlpmetric v0.42.0 // indirect
go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v0.42.0 // indirect
go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v0.42.0 // indirect
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0 // indirect
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.19.0 // indirect
go.opentelemetry.io/otel/exporters/prometheus v0.42.0 // indirect
go.opentelemetry.io/otel/metric v1.21.0 // indirect
go.opentelemetry.io/otel/sdk/metric v1.19.0 // indirect
go.uber.org/multierr v1.11.0 // indirect
golang.org/x/image v0.14.0 // indirect
golang.org/x/time v0.3.0 // indirect
golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect
gonum.org/v1/plot v0.14.0 // indirect
google.golang.org/appengine v1.6.8 // indirect
google.golang.org/genproto v0.0.0-20231106174013-bbf56f31fb17 // indirect
google.golang.org/genproto/googleapis/api v0.0.0-20231106174013-bbf56f31fb17 // indirect
google.golang.org/genproto/googleapis/rpc v0.0.0-20231106174013-bbf56f31fb17 // indirect
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
gopkg.in/warnings.v0 v0.1.2 // indirect
)
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,687 | 🐞 Directory.glob with recursive patterns (`**/*.go`) returns duplicates and is very slow | ### What is the issue?
It looks like Buildkit returns weird results when you `ReadDir` with a glob like `**/*.go`. It actually seems to find everything recursively, but then trim each result to only have the first path segment. So for `a/1.go a/2.go b/3.go` it'll return `a a b`. We then recurse into `a` twice, which will also have this issue, so it quickly explodes into a huge number of results.
We could work around this issue by deduping, but it would probably be better to fix this upstream in Buildkit. It would be perfect if it just returned all the full paths, which it *seems* capable of doing. Then we wouldn't need to recurse ourselves. While we're there, maybe we could add support for exclude filters too (edit: interestingly it seems to support `!` prefixes for exclusions - maybe we should be phasing out `include: ["a"], exclude: ["b"]` in favor of `globs: ["a", "!b"]`?).
cc @jedevc @TomChv for continuity from [https://github.com/dagger/dagger/pull/5824#discussion_r1350193214](https://github.com/dagger/dagger/pull/5824#discussion_r1350193214)
### Dagger version
v0.9.1+ (when the feature was added; not a regression)
### Steps to reproduce
```graphql
{
git(url:"https://github.com/dagger/dagger") {
branch(name:"main"){
tree {
glob(pattern:"**/dagger.json")
}
}
}
}
```
### Log output
```json
{
"data": {
"git": {
"branch": {
"tree": {
"glob": [
"ci/dagger.json",
"core/integration/testdata/modules/go/basic/dagger.json",
"core/integration/testdata/modules/go/broken/dagger.json",
"core/integration/testdata/modules/go/ifaces/dagger.json",
"core/integration/testdata/modules/go/ifaces/impl/dagger.json",
"core/integration/testdata/modules/go/ifaces/test/dagger.json",
"core/integration/testdata/modules/go/namespacing/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub1/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub2/dagger.json",
"core/integration/testdata/modules/go/basic/dagger.json",
"core/integration/testdata/modules/go/broken/dagger.json",
"core/integration/testdata/modules/go/ifaces/dagger.json",
"core/integration/testdata/modules/go/ifaces/impl/dagger.json",
"core/integration/testdata/modules/go/ifaces/test/dagger.json",
"core/integration/testdata/modules/go/namespacing/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub1/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub2/dagger.json",
"core/integration/testdata/modules/go/basic/dagger.json",
"core/integration/testdata/modules/go/broken/dagger.json",
"core/integration/testdata/modules/go/ifaces/dagger.json",
"core/integration/testdata/modules/go/ifaces/impl/dagger.json",
"core/integration/testdata/modules/go/ifaces/test/dagger.json",
"core/integration/testdata/modules/go/namespacing/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub1/dagger.json",
"core/integration/testdata/modules/go/namespacing/sub2/dagger.json",
// you get the idea
``` | https://github.com/dagger/dagger/issues/6687 | https://github.com/dagger/dagger/pull/6852 | 0d815c84455006adb0187f6aa144bfe1356a35cc | 49863fb3638be2bfc351fc8db3d5b1a4fc5668e7 | "2024-02-18T01:09:37Z" | go | "2024-03-07T16:43:26Z" | go.sum | bazil.org/fuse v0.0.0-20160811212531-371fbbdaa898/go.mod h1:Xbm+BRKSBEpa4q4hTSxohYNQpsxXPbPry4JJWOB3LB8=
bazil.org/fuse v0.0.0-20180421153158-65cc252bf669/go.mod h1:Xbm+BRKSBEpa4q4hTSxohYNQpsxXPbPry4JJWOB3LB8=
cdr.dev/slog v1.4.2 h1:fIfiqASYQFJBZiASwL825atyzeA96NsqSxx2aL61P8I=
cdr.dev/slog v1.4.2/go.mod h1:0EkH+GkFNxizNR+GAXUEdUHanxUH5t9zqPILmPM/Vn8=
cloud.google.com/go v0.25.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
cloud.google.com/go v0.31.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
cloud.google.com/go v0.37.2/go.mod h1:H8IAquKe2L30IxoupDgqTaQvKSwF/c8prYHynGIWQbA=
cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
cloud.google.com/go v0.39.0/go.mod h1:rVLT6fkc8chs9sfPtFc1SBH6em7n+ZoXaG+87tDISts=
cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
cloud.google.com/go v0.51.0/go.mod h1:hWtGJ6gnXH+KgDv+V0zFGDvpi07n3z8ZNj3T1RW0Gcw=
cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI=
cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk=
cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg=
cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8=
cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0=
cloud.google.com/go v0.83.0/go.mod h1:Z7MJUsANfY0pYPdw0lbnivPx4/vhy/e2FEkSkF7vAVY=
cloud.google.com/go v0.84.0/go.mod h1:RazrYuxIK6Kb7YrzzhPoLmCVzl7Sup4NrbKPg8KHSUM=
cloud.google.com/go v0.87.0/go.mod h1:TpDYlFy7vuLzZMMZ+B6iRiELaY7z/gJPaqbMx6mlWcY=
cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aDQ=
cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI=
cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4=
cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc=
cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA=
cloud.google.com/go v0.100.2/go.mod h1:4Xra9TjzAeYHrl5+oeLlzbM2k3mjVhZh4UqTZ//w99A=
cloud.google.com/go v0.102.0/go.mod h1:oWcCzKlqJ5zgHQt9YsaeTY9KzIvjyy0ArmiBUgpQ+nc=
cloud.google.com/go v0.110.10 h1:LXy9GEO+timppncPIAZoOj3l58LIU9k+kn48AN7IO3Y=
cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
cloud.google.com/go/compute v0.1.0/go.mod h1:GAesmwr110a34z04OlxYkATPBEfVhkymfTBXtfbBFow=
cloud.google.com/go/compute v1.3.0/go.mod h1:cCZiE1NHEtai4wiufUhW8I8S1JKkAnhnQJWM7YD99wM=
cloud.google.com/go/compute v1.5.0/go.mod h1:9SMHyhJlzhlkJqrPAc839t2BZFTSk6Jdj6mkzQJeu0M=
cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz/FMzPu0s=
cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU=
cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U=
cloud.google.com/go/compute v1.23.3 h1:6sVlXXBmbd7jNX0Ipq0trII3e4n1/MsADLK6a+aiVlk=
cloud.google.com/go/compute v1.23.3/go.mod h1:VCgBUoMnIVIR0CscqQiPJLAG25E3ZRZMzcFZeQ+h8CI=
cloud.google.com/go/compute/metadata v0.2.3 h1:mg4jlk7mCAj6xXp9UJ4fjI9VUI5rubuGBW5aJ7UnBMY=
cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA=
cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqClKRT5SZwBmk=
cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY=
cloud.google.com/go/logging v1.8.1 h1:26skQWPeYhvIasWKm48+Eq7oUqdcdbwsCVwz5Ys0FvU=
cloud.google.com/go/logging v1.8.1/go.mod h1:TJjR+SimHwuC8MZ9cjByQulAMgni+RkXeI3wwctHJEI=
cloud.google.com/go/longrunning v0.5.4 h1:w8xEcbZodnA2BbW6sVirkkoC+1gP8wS57EUUgGS0GVg=
cloud.google.com/go/longrunning v0.5.4/go.mod h1:zqNVncI0BOP8ST6XQD1+VcvuShMmq7+xFSzOL++V0dI=
cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y=
code.gitea.io/sdk/gitea v0.12.0/go.mod h1:z3uwDV/b9Ls47NGukYM9XhnHtqPh/J+t40lsUrR6JDY=
contrib.go.opencensus.io/exporter/aws v0.0.0-20181029163544-2befc13012d0/go.mod h1:uu1P0UCM/6RbsMrgPa98ll8ZcHM858i/AD06a9aLRCA=
contrib.go.opencensus.io/exporter/ocagent v0.5.0/go.mod h1:ImxhfLRpxoYiSq891pBrLVhN+qmP8BTVvdH2YLs7Gl0=
contrib.go.opencensus.io/exporter/stackdriver v0.12.1/go.mod h1:iwB6wGarfphGGe/e5CWqyUk/cLzKnWsOKPVW3no6OTw=
contrib.go.opencensus.io/integrations/ocsql v0.1.4/go.mod h1:8DsSdjz3F+APR+0z0WkU1aRorQCFfRxvqjUUPMbF3fE=
contrib.go.opencensus.io/resource v0.1.1/go.mod h1:F361eGI91LCmW1I/Saf+rX0+OFcigGlFvXwEGEnkRLA=
dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk=
dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
git.apache.org/thrift.git v0.0.0-20180902110319-2566ecd5d999/go.mod h1:fPE2ZNJGynbRyZ4dJvy6G277gSllfV2HJqblrnkyeyg=
git.apache.org/thrift.git v0.12.0/go.mod h1:fPE2ZNJGynbRyZ4dJvy6G277gSllfV2HJqblrnkyeyg=
git.sr.ht/~sbinet/gg v0.5.0 h1:6V43j30HM623V329xA9Ntq+WJrMjDxRjuAB1LFWF5m8=
git.sr.ht/~sbinet/gg v0.5.0/go.mod h1:G2C0eRESqlKhS7ErsNey6HHrqU1PwsnCQlekFi9Q2Oo=
github.com/99designs/gqlgen v0.17.41 h1:C1/zYMhGVP5TWNCNpmZ9Mb6CqT1Vr5SHEWoTOEJ3v3I=
github.com/99designs/gqlgen v0.17.41/go.mod h1:GQ6SyMhwFbgHR0a8r2Wn8fYgEwPxxmndLFPhU63+cJE=
github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24 h1:bvDV9vkmnHYOMsOr4WLk+Vo07yKIzd94sVoIqshQ4bU=
github.com/AdaLogics/go-fuzz-headers v0.0.0-20230811130428-ced1acdcaa24/go.mod h1:8o94RPi1/7XTJvwPpRSzSUedZrtlirdB3r9Z20bi2f8=
github.com/AdamKorcz/go-118-fuzz-build v0.0.0-20230306123547-8075edf89bb0 h1:59MxjQVfjXsBpLy+dbd2/ELV5ofnUkUZBvWSC85sheA=
github.com/AdamKorcz/go-118-fuzz-build v0.0.0-20230306123547-8075edf89bb0/go.mod h1:OahwfttHWG6eJ0clwcfBAHoDI6X/LV/15hx/wlMZSrU=
github.com/AkihiroSuda/containerd-fuse-overlayfs v1.0.0/go.mod h1:0mMDvQFeLbbn1Wy8P2j3hwFhqBq+FKn8OZPno8WLmp8=
github.com/Azure/azure-amqp-common-go/v2 v2.1.0/go.mod h1:R8rea+gJRuJR6QxTir/XuEd+YuKoUiazDC/N96FiDEU=
github.com/Azure/azure-pipeline-go v0.2.1/go.mod h1:UGSo8XybXnIGZ3epmeBw7Jdz+HiUVpqIlpz/HKHylF4=
github.com/Azure/azure-pipeline-go v0.2.2/go.mod h1:4rQ/NZncSvGqNkkOsNpOU1tgoNuIlp9AfUH5G1tvCHc=
github.com/Azure/azure-sdk-for-go v16.2.1+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
github.com/Azure/azure-sdk-for-go v19.1.1+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
github.com/Azure/azure-sdk-for-go v29.0.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
github.com/Azure/azure-sdk-for-go v30.1.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
github.com/Azure/azure-sdk-for-go v35.0.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
github.com/Azure/azure-sdk-for-go v38.0.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
github.com/Azure/azure-sdk-for-go v42.3.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
github.com/Azure/azure-sdk-for-go/sdk/azcore v1.1.0 h1:Ut0ZGdOwJDw0npYEg+TLlPls3Pq6JiZaP2/aGKir7Zw=
github.com/Azure/azure-sdk-for-go/sdk/azcore v1.1.0/go.mod h1:uGG2W01BaETf0Ozp+QxxKJdMBNRWPdstHG0Fmdwn1/U=
github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.1.0 h1:QkAcEIAKbNL4KoFr4SathZPhDhF4mVwpBMFlYjyAqy8=
github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.1.0/go.mod h1:bhXu1AjYL+wutSL/kpSq6s7733q2Rb0yuot9Zgfqa/0=
github.com/Azure/azure-sdk-for-go/sdk/internal v1.0.0 h1:jp0dGvZ7ZK0mgqnTSClMxa5xuRL7NZgHameVYF6BurY=
github.com/Azure/azure-sdk-for-go/sdk/internal v1.0.0/go.mod h1:eWRD7oawr1Mu1sLCawqVc0CUiF43ia3qQMxLscsKQ9w=
github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v0.4.1 h1:QSdcrd/UFJv6Bp/CfoVf2SrENpFn9P6Yh8yb+xNhYMM=
github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v0.4.1/go.mod h1:eZ4g6GUvXiGulfIbbhh1Xr4XwUYaYaWMqzGD/284wCA=
github.com/Azure/azure-service-bus-go v0.9.1/go.mod h1:yzBx6/BUGfjfeqbRZny9AQIbIe3AcV9WZbAdpkoXOa0=
github.com/Azure/azure-storage-blob-go v0.8.0/go.mod h1:lPI3aLPpuLTeUwh1sViKXFxwl2B6teiRqI0deQUvsw0=
github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8=
github.com/Azure/go-autorest v10.8.1+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24=
github.com/Azure/go-autorest v10.15.5+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24=
github.com/Azure/go-autorest v12.0.0+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24=
github.com/Azure/go-autorest v14.1.1+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24=
github.com/Azure/go-autorest/autorest v0.9.0/go.mod h1:xyHB1BMZT0cuDHU7I0+g046+BFDTQ8rEZB0s4Yfa6bI=
github.com/Azure/go-autorest/autorest v0.9.3/go.mod h1:GsRuLYvwzLjjjRoWEIyMUaYq8GNUx2nRB378IPt/1p0=
github.com/Azure/go-autorest/autorest v0.9.6/go.mod h1:/FALq9T/kS7b5J5qsQ+RSTUdAmGFqi0vUdVNNx8q630=
github.com/Azure/go-autorest/autorest v0.10.2/go.mod h1:/FALq9T/kS7b5J5qsQ+RSTUdAmGFqi0vUdVNNx8q630=
github.com/Azure/go-autorest/autorest/adal v0.5.0/go.mod h1:8Z9fGy2MpX0PvDjB1pEgQTmVqjGhiHBW7RJJEciWzS0=
github.com/Azure/go-autorest/autorest/adal v0.8.0/go.mod h1:Z6vX6WXXuyieHAXwMj0S6HY6e6wcHn37qQMBQlvY3lc=
github.com/Azure/go-autorest/autorest/adal v0.8.1/go.mod h1:ZjhuQClTqx435SRJ2iMlOxPYt3d2C/T/7TiQCVZSn3Q=
github.com/Azure/go-autorest/autorest/adal v0.8.2/go.mod h1:ZjhuQClTqx435SRJ2iMlOxPYt3d2C/T/7TiQCVZSn3Q=
github.com/Azure/go-autorest/autorest/adal v0.8.3/go.mod h1:ZjhuQClTqx435SRJ2iMlOxPYt3d2C/T/7TiQCVZSn3Q=
github.com/Azure/go-autorest/autorest/azure/auth v0.4.2/go.mod h1:90gmfKdlmKgfjUpnCEpOJzsUEjrWDSLwHIG73tSXddM=
github.com/Azure/go-autorest/autorest/azure/cli v0.3.1/go.mod h1:ZG5p860J94/0kI9mNJVoIoLgXcirM2gF5i2kWloofxw=
github.com/Azure/go-autorest/autorest/date v0.1.0/go.mod h1:plvfp3oPSKwf2DNjlBjWF/7vwR+cUD/ELuzDCXwHUVA=
github.com/Azure/go-autorest/autorest/date v0.2.0/go.mod h1:vcORJHLJEh643/Ioh9+vPmf1Ij9AEBM5FuBIXLmIy0g=
github.com/Azure/go-autorest/autorest/mocks v0.1.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0=
github.com/Azure/go-autorest/autorest/mocks v0.2.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0=
github.com/Azure/go-autorest/autorest/mocks v0.3.0/go.mod h1:a8FDP3DYzQ4RYfVAxAN3SVSiiO77gL2j2ronKKP0syM=
github.com/Azure/go-autorest/autorest/to v0.2.0/go.mod h1:GunWKJp1AEqgMaGLV+iocmRAJWqST1wQYhyyjXJ3SJc=
github.com/Azure/go-autorest/autorest/to v0.3.0/go.mod h1:MgwOyqaIuKdG4TL/2ywSsIWKAfJfgHDo8ObuUk3t5sA=
github.com/Azure/go-autorest/autorest/validation v0.1.0/go.mod h1:Ha3z/SqBeaalWQvokg3NZAlQTalVMtOIAs1aGK7G6u8=
github.com/Azure/go-autorest/autorest/validation v0.2.0/go.mod h1:3EEqHnBxQGHXRYq3HT1WyXAvT7LLY3tl70hw6tQIbjI=
github.com/Azure/go-autorest/logger v0.1.0/go.mod h1:oExouG+K6PryycPJfVSxi/koC6LSNgds39diKLz7Vrc=
github.com/Azure/go-autorest/tracing v0.5.0/go.mod h1:r/s2XiOKccPW3HrqB+W0TQzfbtp2fGCgRFtBroKn4Dk=
github.com/AzureAD/microsoft-authentication-library-for-go v0.6.0 h1:XMEdVDFxgulDDl0lQmAZS6j8gRQ/0pJ+ZpXH2FHVtDc=
github.com/AzureAD/microsoft-authentication-library-for-go v0.6.0/go.mod h1:BDJ5qMFKx9DugEg3+uQSDCdbYPr5s9vBTrL9P8TpqOU=
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
github.com/Djarvur/go-err113 v0.0.0-20200410182137-af658d038157/go.mod h1:4UJr5HIiMZrwgkSPdsjy2uOQExX/WEILpIrO9UPGuXs=
github.com/Djarvur/go-err113 v0.1.0/go.mod h1:4UJr5HIiMZrwgkSPdsjy2uOQExX/WEILpIrO9UPGuXs=
github.com/GoogleCloudPlatform/cloudsql-proxy v0.0.0-20191009163259-e802c2cb94ae/go.mod h1:mjwGPas4yKduTyubHvD1Atl9r1rUq8DfVy+gkVvZ+oo=
github.com/GoogleCloudPlatform/k8s-cloud-provider v0.0.0-20190822182118-27a4ced34534/go.mod h1:iroGtC8B3tQiqtds1l+mgk/BBOrxbqjH+eUfFQYRc14=
github.com/Khan/genqlient v0.6.0 h1:Bwb1170ekuNIVIwTJEqvO8y7RxBxXu639VJOkKSrwAk=
github.com/Khan/genqlient v0.6.0/go.mod h1:rvChwWVTqXhiapdhLDV4bp9tz/Xvtewwkon4DpWWCRM=
github.com/MakeNowJust/heredoc/v2 v2.0.1 h1:rlCHh70XXXv7toz95ajQWOWQnN4WNLt0TdpZYIR/J6A=
github.com/MakeNowJust/heredoc/v2 v2.0.1/go.mod h1:6/2Abh5s+hc3g9nbWLe9ObDIOhaRrqsyY9MWy+4JdRM=
github.com/Masterminds/semver v1.5.0 h1:H65muMkzWKEuNDnfl9d70GUjFniHKHRbFPGBuZ3QEww=
github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
github.com/Masterminds/semver/v3 v3.0.3/go.mod h1:VPu/7SZ7ePZ3QOrcuXROw5FAcLl4a0cBrbBpGY/8hQs=
github.com/Masterminds/semver/v3 v3.1.0 h1:Y2lUDsFKVRSYGojLJ1yLxSXdMmMYTYls0rCvoqmMUQk=
github.com/Masterminds/semver/v3 v3.1.0/go.mod h1:VPu/7SZ7ePZ3QOrcuXROw5FAcLl4a0cBrbBpGY/8hQs=
github.com/Microsoft/go-winio v0.4.14/go.mod h1:qXqCSQ3Xa7+6tgxaGTIe4Kpcdsi+P8jBhyzoq1bpyYA=
github.com/Microsoft/go-winio v0.4.15-0.20190919025122-fc70bd9a86b5/go.mod h1:tTuCMEN+UleMWgg9dVx4Hu52b1bJo+59jBh3ajtinzw=
github.com/Microsoft/go-winio v0.4.15-0.20200908182639-5b44b70ab3ab/go.mod h1:tTuCMEN+UleMWgg9dVx4Hu52b1bJo+59jBh3ajtinzw=
github.com/Microsoft/go-winio v0.4.15/go.mod h1:tTuCMEN+UleMWgg9dVx4Hu52b1bJo+59jBh3ajtinzw=
github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY=
github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
github.com/Microsoft/hcsshim v0.8.7/go.mod h1:OHd7sQqRFrYd3RmSgbgji+ctCwkbq2wbEYNSzOYtcBQ=
github.com/Microsoft/hcsshim v0.8.9/go.mod h1:5692vkUqntj1idxauYlpoINNKeqCiG6Sg38RRsjT5y8=
github.com/Microsoft/hcsshim v0.8.10/go.mod h1:g5uw8EV2mAlzqe94tfNBNdr89fnbD/n3HV0OhsddkmM=
github.com/Microsoft/hcsshim v0.11.4 h1:68vKo2VN8DE9AdN4tnkWnmdhqdbpUFM8OF3Airm7fz8=
github.com/Microsoft/hcsshim v0.11.4/go.mod h1:smjE4dvqPX9Zldna+t5FG3rnoHhaB7QYxPRqGcpAD9w=
github.com/Microsoft/hcsshim/test v0.0.0-20200826032352-301c83a30e7c/go.mod h1:30A5igQ91GEmhYJF8TaRP79pMBOYynRsyOByfVV0dU4=
github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb06e3pkSAbeQ52E9H9iFoQsEEwGN64994WTCIhntQ=
github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2 h1:+vx7roKuyA63nhn5WAunQHLTznkw5W8b1Xc0dNjp83s=
github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2/go.mod h1:HBCaDeC1lPdgDeDbhX8XFpy1jqjK0IBG8W5K+xYqA0w=
github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
github.com/OpenPeeDeeP/depguard v1.0.1/go.mod h1:xsIw86fROiiwelg+jB2uM9PiKihMMmUx/1V+TNhjQvM=
github.com/ProtonMail/go-crypto v0.0.0-20230828082145-3c4c8a2d2371 h1:kkhsdkhsCvIsutKu5zLMgWtgh9YxGCNAw8Ad8hjwfYg=
github.com/ProtonMail/go-crypto v0.0.0-20230828082145-3c4c8a2d2371/go.mod h1:EjAoLdwvbIOoOQr3ihjnSoLZRtE8azugULFRteWMNc0=
github.com/PuerkitoBio/goquery v1.8.1 h1:uQxhNlArOIdbrH1tr0UXwdVFgDcZDrZVdcpygAcwmWM=
github.com/PuerkitoBio/goquery v1.8.1/go.mod h1:Q8ICL1kNUJ2sXGoAhPGUdYDJvgQgHzJsnnd3H7Ho5jQ=
github.com/PuerkitoBio/purell v1.0.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0=
github.com/PuerkitoBio/purell v1.1.1/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0=
github.com/PuerkitoBio/urlesc v0.0.0-20160726150825-5bd2802263f2/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
github.com/Shopify/logrus-bugsnag v0.0.0-20171204204709-577dee27f20d/go.mod h1:HI8ITrYtUY+O+ZhtlqUnD8+KwNPOyugEhfP9fdUIaEQ=
github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo=
github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=
github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg=
github.com/a-h/templ v0.2.543 h1:8YyLvyUtf0/IE2nIwZ62Z/m2o2NqwhnMynzOL78Lzbk=
github.com/a-h/templ v0.2.543/go.mod h1:jP908DQCwI08IrnTalhzSEH9WJqG/Q94+EODQcJGFUA=
github.com/adrg/xdg v0.4.0 h1:RzRqFcjH4nE5C6oTAxhBtoE2IRyjBSa62SCbyPidvls=
github.com/adrg/xdg v0.4.0/go.mod h1:N6ag73EX4wyxeaoeHctc1mas01KZgsj5tYiAIwqJE/E=
github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo=
github.com/agext/levenshtein v1.2.3/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
github.com/agnivade/levenshtein v1.1.1 h1:QY8M92nrzkmr798gCo3kmMyqXFzdQVpxLlGPRBij0P8=
github.com/agnivade/levenshtein v1.1.1/go.mod h1:veldBMzWxcCG2ZvUTKD2kJNRdCk5hVbJomOvKkmgYbo=
github.com/ajstarks/svgo v0.0.0-20211024235047-1546f124cd8b h1:slYM766cy2nI3BwyRiyQj/Ud48djTMtMebDqepE95rw=
github.com/ajstarks/svgo v0.0.0-20211024235047-1546f124cd8b/go.mod h1:1KcenG0jGWcpt8ov532z81sp/kMMUG485J2InIOyADM=
github.com/alecthomas/assert/v2 v2.2.1 h1:XivOgYcduV98QCahG8T5XTezV5bylXe+lBxLG2K2ink=
github.com/alecthomas/assert/v2 v2.2.1/go.mod h1:pXcQ2Asjp247dahGEmsZ6ru0UVwnkhktn7S0bBDLxvQ=
github.com/alecthomas/chroma v0.10.0 h1:7XDcGkCQopCNKjZHfYrNLraA+M7e0fMiJ/Mfikbfjek=
github.com/alecthomas/chroma v0.10.0/go.mod h1:jtJATyUxlIORhUOFNA9NZDWGAQ8wpxQQqNSB4rjA/1s=
github.com/alecthomas/chroma/v2 v2.11.1 h1:m9uUtgcdAwgfFNxuqj7AIG75jD2YmL61BBIJWtdzJPs=
github.com/alecthomas/chroma/v2 v2.11.1/go.mod h1:4TQu7gdfuPjSh76j78ietmqh9LiurGF0EpseFXdKMBw=
github.com/alecthomas/kingpin v2.2.6+incompatible/go.mod h1:59OFYbFVLKQKq+mqrL6Rw5bR0c3ACQaawgXx0QYndlE=
github.com/alecthomas/repr v0.2.0 h1:HAzS41CIzNW5syS8Mf9UwXhNH1J9aix/BvDRf1Ml2Yk=
github.com/alecthomas/repr v0.2.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
github.com/alecthomas/units v0.0.0-20211218093645-b94a6e3cc137/go.mod h1:OMCwj8VM1Kc9e19TLln2VL61YJF0x1XFtfdL4JdbSyE=
github.com/anchore/go-struct-converter v0.0.0-20221118182256-c68fdcfa2092 h1:aM1rlcoLz8y5B2r4tTLMiVTrMtpfY0O8EScKJxaSaEc=
github.com/anchore/go-struct-converter v0.0.0-20221118182256-c68fdcfa2092/go.mod h1:rYqSE9HbjzpHTI74vwPvae4ZVYZd1lue2ta6xHPdblA=
github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883 h1:bvNMNQO63//z+xNgfBlViaCIJKLlCJ6/fmUseuG0wVQ=
github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8=
github.com/andybalholm/cascadia v1.3.1/go.mod h1:R4bJ1UQfqADjvDa4P6HZHLh/3OxWWEqc0Sk8XGwHqvA=
github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss=
github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU=
github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8=
github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4=
github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
github.com/apex/log v1.1.4/go.mod h1:AlpoD9aScyQfJDVHmLMEcx4oU6LqzkWp4Mg9GdAcEvQ=
github.com/apex/log v1.3.0/go.mod h1:jd8Vpsr46WAe3EZSQ/IUMs2qQD/GOycT5rPWCO1yGcs=
github.com/apex/logs v0.0.4/go.mod h1:XzxuLZ5myVHDy9SAmYpamKKRNApGj54PfYLcFrXqDwo=
github.com/aphistic/golf v0.0.0-20180712155816-02c07f170c5a/go.mod h1:3NqKYiepwy8kCu4PNA+aP7WUV72eXWJeP9/r3/K9aLE=
github.com/aphistic/sweet v0.2.0/go.mod h1:fWDlIh/isSE9n6EPsRmC0det+whmX6dJid3stzu0Xys=
github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0 h1:jfIu9sQUG6Ig+0+Ap1h4unLjW6YQJpKZVmUzxsD4E/Q=
github.com/arbovm/levenshtein v0.0.0-20160628152529-48b4e1c0c4d0/go.mod h1:t2tdKJDJF9BV14lnkjHmOQgcvEKgtqs5a1N3LNdJhGE=
github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
github.com/armon/circbuf v0.0.0-20190214190532-5111143e8da2 h1:7Ip0wMmLHLRJdrloDxZfhMm0xrLXZS8+COSu2bXmEQs=
github.com/armon/circbuf v0.0.0-20190214190532-5111143e8da2/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
github.com/aws/aws-sdk-go v1.15.11/go.mod h1:mFuSZ37Z9YOHbQEwBWztmVzqXrEkub65tZoCYDt7FT0=
github.com/aws/aws-sdk-go v1.15.27/go.mod h1:mFuSZ37Z9YOHbQEwBWztmVzqXrEkub65tZoCYDt7FT0=
github.com/aws/aws-sdk-go v1.15.90/go.mod h1:es1KtYUFs7le0xQ3rOihkuoVD90z7D0fR2Qm4S00/gU=
github.com/aws/aws-sdk-go v1.16.26/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
github.com/aws/aws-sdk-go v1.19.18/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
github.com/aws/aws-sdk-go v1.19.45/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
github.com/aws/aws-sdk-go v1.20.6/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
github.com/aws/aws-sdk-go v1.25.11/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
github.com/aws/aws-sdk-go v1.27.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
github.com/aws/aws-sdk-go v1.27.1/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
github.com/aws/aws-sdk-go v1.31.6/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
github.com/aws/aws-sdk-go-v2 v1.24.1 h1:xAojnj+ktS95YZlDf0zxWBkbFtymPeDP+rvUQIH3uAU=
github.com/aws/aws-sdk-go-v2 v1.24.1/go.mod h1:LNh45Br1YAkEKaAqvmE1m8FUx6a5b/V0oAKV7of29b4=
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.5.4 h1:OCs21ST2LrepDfD3lwlQiOqIGp6JiEUqG84GzTDoyJs=
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.5.4/go.mod h1:usURWEKSNNAcAZuzRn/9ZYPT8aZQkR7xcCtunK/LkJo=
github.com/aws/aws-sdk-go-v2/config v1.26.6 h1:Z/7w9bUqlRI0FFQpetVuFYEsjzE3h7fpU6HuGmfPL/o=
github.com/aws/aws-sdk-go-v2/config v1.26.6/go.mod h1:uKU6cnDmYCvJ+pxO9S4cWDb2yWWIH5hra+32hVh1MI4=
github.com/aws/aws-sdk-go-v2/credentials v1.16.16 h1:8q6Rliyv0aUFAVtzaldUEcS+T5gbadPbWdV1WcAddK8=
github.com/aws/aws-sdk-go-v2/credentials v1.16.16/go.mod h1:UHVZrdUsv63hPXFo1H7c5fEneoVo9UXiz36QG1GEPi0=
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11 h1:c5I5iH+DZcH3xOIMlz3/tCKJDaHFwYEmxvlh2fAcFo8=
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.11/go.mod h1:cRrYDYAMUohBJUtUnOhydaMHtiK/1NZ0Otc9lIb6O0Y=
github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.15.15 h1:2MUXyGW6dVaQz6aqycpbdLIH1NMcUI6kW6vQ0RabGYg=
github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.15.15/go.mod h1:aHbhbR6WEQgHAiRj41EQ2W47yOYwNtIkWTXmcAtYqj8=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10 h1:vF+Zgd9s+H4vOXd5BMaPWykta2a6Ih0AKLq/X6NYKn4=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.10/go.mod h1:6BkRjejp/GR4411UGqkX8+wFMbFbqsUIimfK4XjOKR4=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10 h1:nYPe006ktcqUji8S2mqXf9c/7NdiKriOwMvWQHgYztw=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.10/go.mod h1:6UV4SZkVvmODfXKql4LCbaZUpF7HO2BX38FgBf9ZOLw=
github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3 h1:n3GDfwqF2tzEkXlv5cuy4iy7LpKDtqDMcNLfZDu9rls=
github.com/aws/aws-sdk-go-v2/internal/ini v1.7.3/go.mod h1:6fQQgfuGmw8Al/3M2IgIllycxV7ZW7WCdVSqfBeUiCY=
github.com/aws/aws-sdk-go-v2/internal/v4a v1.2.10 h1:5oE2WzJE56/mVveuDZPJESKlg/00AaS2pY2QZcnxg4M=
github.com/aws/aws-sdk-go-v2/internal/v4a v1.2.10/go.mod h1:FHbKWQtRBYUz4vO5WBWjzMD2by126ny5y/1EoaWoLfI=
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4 h1:/b31bi3YVNlkzkBrm9LfpaKoaYZUxIAj4sHfOTmLfqw=
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.4/go.mod h1:2aGXHFmbInwgP9ZfpmdIfOELL79zhdNYNmReK8qDfdQ=
github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.2.10 h1:L0ai8WICYHozIKK+OtPzVJBugL7culcuM4E4JOpIEm8=
github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.2.10/go.mod h1:byqfyxJBshFk0fF9YmK0M0ugIO8OWjzH2T3bPG4eGuA=
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10 h1:DBYTXwIGQSGs9w4jKm60F5dmCQ3EEruxdc0MFh+3EY4=
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.10/go.mod h1:wohMUQiFdzo0NtxbBg0mSRGZ4vL3n0dKjLTINdcIino=
github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.16.10 h1:KOxnQeWy5sXyS37fdKEvAsGHOr9fa/qvwxfJurR/BzE=
github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.16.10/go.mod h1:jMx5INQFYFYB3lQD9W0D8Ohgq6Wnl7NYOJ2TQndbulI=
github.com/aws/aws-sdk-go-v2/service/s3 v1.48.1 h1:5XNlsBsEvBZBMO6p82y+sqpWg8j5aBCe+5C2GBFgqBQ=
github.com/aws/aws-sdk-go-v2/service/s3 v1.48.1/go.mod h1:4qXHrG1Ne3VGIMZPCB8OjH/pLFO94sKABIusjh0KWPU=
github.com/aws/aws-sdk-go-v2/service/sso v1.18.7 h1:eajuO3nykDPdYicLlP3AGgOyVN3MOlFmZv7WGTuJPow=
github.com/aws/aws-sdk-go-v2/service/sso v1.18.7/go.mod h1:+mJNDdF+qiUlNKNC3fxn74WWNN+sOiGOEImje+3ScPM=
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7 h1:QPMJf+Jw8E1l7zqhZmMlFw6w1NmfkfiSK8mS4zOx3BA=
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.21.7/go.mod h1:ykf3COxYI0UJmxcfcxcVuz7b6uADi1FkiUz6Eb7AgM8=
github.com/aws/aws-sdk-go-v2/service/sts v1.26.7 h1:NzO4Vrau795RkUdSHKEwiR01FaGzGOH1EETJ+5QHnm0=
github.com/aws/aws-sdk-go-v2/service/sts v1.26.7/go.mod h1:6h2YuIoxaMSCFf5fi1EgZAwdfkGMgDY+DVfa61uLe4U=
github.com/aws/smithy-go v1.19.0 h1:KWFKQV80DpP3vJrrA9sVAHQ5gc2z8i4EzrLhLlWXcBM=
github.com/aws/smithy-go v1.19.0/go.mod h1:NukqUGpCZIILqqiV0NIjeFh24kd/FAa4beRb6nbIUPE=
github.com/aybabtme/rgbterm v0.0.0-20170906152045-cc83f3b3ce59/go.mod h1:q/89r3U2H7sSsE2t6Kca0lfwTK8JdoNGS/yzM/4iH5I=
github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
github.com/beorn7/perks v0.0.0-20160804104726-4c0e84591b9a/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
github.com/bitly/go-simplejson v0.5.0/go.mod h1:cXHtHw4XUPsvGaxgjIAn8PhEWG9NfngEKAMDJEczWVA=
github.com/bketelsen/crypt v0.0.3-0.20200106085610-5cbc8cc4026c/go.mod h1:MKsuJmJgSg28kpZDP6UIiPt0e0Oz0kqKNGyRaWEPv84=
github.com/blakesmith/ar v0.0.0-20190502131153-809d4375e1fb/go.mod h1:PkYb9DJNAwrSvRx5DYA+gUcOIgTGVMNkfSCbZM8cWpI=
github.com/blang/semver v3.1.0+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=
github.com/blang/semver v3.5.0+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=
github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ=
github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=
github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4=
github.com/bombsimon/wsl/v2 v2.0.0/go.mod h1:mf25kr/SqFEPhhcxW1+7pxzGlW+hIl/hYTKY95VwV8U=
github.com/bombsimon/wsl/v2 v2.2.0/go.mod h1:Azh8c3XGEJl9LyX0/sFC+CKMc7Ssgua0g+6abzXN4Pg=
github.com/bombsimon/wsl/v3 v3.0.0/go.mod h1:st10JtZYLE4D5sC7b8xV4zTKZwAQjCH/Hy2Pm1FNZIc=
github.com/bombsimon/wsl/v3 v3.1.0/go.mod h1:st10JtZYLE4D5sC7b8xV4zTKZwAQjCH/Hy2Pm1FNZIc=
github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g=
github.com/bshuster-repo/logrus-logstash-hook v0.4.1/go.mod h1:zsTqEiSzDgAa/8GZR7E1qaXrhYNDKBYy5/dWPTIflbk=
github.com/bugsnag/bugsnag-go v0.0.0-20141110184014-b1d153021fcd/go.mod h1:2oa8nejYd4cQ/b0hMIopN0lCRxU0bueqREvZLWFrtK8=
github.com/bugsnag/osext v0.0.0-20130617224835-0dd3f918b21b/go.mod h1:obH5gd0BsqsP2LwDJ9aOkm/6J86V6lyAXCoQWGw3K50=
github.com/bugsnag/panicwrap v0.0.0-20151223152923-e2c28503fcd0/go.mod h1:D/8v3kj0zr8ZAKg1AQ6crr+5VwKN5eIywRkfhyM/+dE=
github.com/bwesterb/go-ristretto v1.2.3/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0=
github.com/caarlos0/ctrlc v1.0.0/go.mod h1:CdXpj4rmq0q/1Eb44M9zi2nKB0QraNKuRGYGrrHhcQw=
github.com/campoy/embedmd v1.0.0 h1:V4kI2qTJJLf4J29RzI/MAt2c3Bl4dQSYPuflzwFH2hY=
github.com/campoy/embedmd v1.0.0/go.mod h1:oxyr9RCiSXg0M3VJ3ks0UGfp98BpSSGr0kpiX3MzVl8=
github.com/campoy/unique v0.0.0-20180121183637-88950e537e7e/go.mod h1:9IOqJGCPMSc6E5ydlp5NIonxObaeu/Iub/X03EKPVYo=
github.com/cavaliercoder/go-cpio v0.0.0-20180626203310-925f9528c45e/go.mod h1:oDpT4efm8tSYHXV5tHSdRvBet/b/QzxZ+XyyPehvm3A=
github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM=
github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
github.com/census-instrumentation/opencensus-proto v0.2.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/charmbracelet/bubbles v0.18.0 h1:PYv1A036luoBGroX6VWjQIE9Syf2Wby2oOl/39KLfy0=
github.com/charmbracelet/bubbles v0.18.0/go.mod h1:08qhZhtIwzgrtBjAcJnij1t1H0ZRjwHyGsy6AL11PSw=
github.com/charmbracelet/bubbletea v0.25.0 h1:bAfwk7jRz7FKFl9RzlIULPkStffg5k6pNt5dywy4TcM=
github.com/charmbracelet/bubbletea v0.25.0/go.mod h1:EN3QDR1T5ZdWmdfDzYcqOCAps45+QIJbLOBxmVNWNNg=
github.com/charmbracelet/harmonica v0.2.0 h1:8NxJWRWg/bzKqqEaaeFNipOu77YR5t8aSwG4pgaUBiQ=
github.com/charmbracelet/harmonica v0.2.0/go.mod h1:KSri/1RMQOZLbw7AHqgcBycp8pgJnQMYYT8QZRqZ1Ao=
github.com/charmbracelet/lipgloss v0.9.1 h1:PNyd3jvaJbg4jRHKWXnCj1akQm4rh8dbEzN1p/u1KWg=
github.com/charmbracelet/lipgloss v0.9.1/go.mod h1:1mPmG4cxScwUQALAAnacHaigiiHB9Pmr+v1VEawJl6I=
github.com/checkpoint-restore/go-criu/v4 v4.1.0/go.mod h1:xUQBLp4RLc5zJtWY++yjOoMoB5lihDt7fai+75m+rGw=
github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
github.com/chzyer/logex v1.2.0/go.mod h1:9+9sk7u7pGNWYMkh0hdiL++6OeibzJccyQU4p4MedaY=
github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
github.com/chzyer/readline v1.5.0/go.mod h1:x22KAscuvRqlLoK9CsoYsmxoXZMMFVyOl86cAH8qUic=
github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
github.com/chzyer/test v0.0.0-20210722231415-061457976a23/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
github.com/cilium/ebpf v0.0.0-20200110133405-4032b1d8aae3/go.mod h1:MA5e5Lr8slmEg9bt0VpxxWqJlO4iwu3FBdHUzV7wQVg=
github.com/cilium/ebpf v0.0.0-20200702112145-1c8d4c9ef775/go.mod h1:7cR51M8ViRLIdUjrmSXlK9pkrsDlLHbO8jiB8X8JnOc=
github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
github.com/cloudflare/circl v1.3.3/go.mod h1:5XYMA4rFBvNIrhs50XuiBJ15vF2pZn4nnUKZrLbUZFA=
github.com/cloudflare/circl v1.3.7 h1:qlCDlTPz2n9fu58M0Nh1J/JzcFpfgkFHHX3O35r5vcU=
github.com/cloudflare/circl v1.3.7/go.mod h1:sRTcRWXGLrKw6yIGJ+l7amYJFfAXbZG0kBSc8r4zxgA=
github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI=
github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cncf/xds/go v0.0.0-20231109132714-523115ebc101 h1:7To3pQ+pZo0i3dsWEbinPNFs5gPSBOsJtx3wTT94VBY=
github.com/cncf/xds/go v0.0.0-20231109132714-523115ebc101/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8=
github.com/codahale/hdrhistogram v0.0.0-20160425231609-f8ad88b59a58/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI=
github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI=
github.com/codahale/rfc6979 v0.0.0-20141003034818-6a90f24967eb h1:EDmT6Q9Zs+SbUoc7Ik9EfrFqcylYqgPZ9ANSbTAntnE=
github.com/codahale/rfc6979 v0.0.0-20141003034818-6a90f24967eb/go.mod h1:ZjrT6AXHbDs86ZSdt/osfBi5qfexBrKUdONk989Wnk4=
github.com/containerd/cgroups v0.0.0-20190919134610-bf292b21730f/go.mod h1:OApqhQ4XNSNC13gXIwDjhOQxjWa/NxkwZXJ1EvqT0ko=
github.com/containerd/cgroups v0.0.0-20200531161412-0dbf7f05ba59/go.mod h1:pA0z1pT8KYB3TCXK/ocprsh7MAkoW8bZVzPdih9snmM=
github.com/containerd/cgroups v0.0.0-20200710171044-318312a37340/go.mod h1:s5q4SojHctfxANBDvMeIaIovkq29IP48TKAxnhYRxvo=
github.com/containerd/cgroups v1.1.0 h1:v8rEWFl6EoqHB+swVNjVoCJE8o3jX7e8nqBGPLaDFBM=
github.com/containerd/cgroups v1.1.0/go.mod h1:6ppBcbh/NOOUU+dMKrykgaBnK9lCIBxHqJDGwsa1mIw=
github.com/containerd/console v0.0.0-20180822173158-c12b1e7919c1/go.mod h1:Tj/on1eG8kiEhd0+fhSDzsPAFESxzBBvdyEgyryXffw=
github.com/containerd/console v0.0.0-20191206165004-02ecf6a7291e/go.mod h1:8Pf4gM6VEbTNRIT26AyyU7hxdQU3MvAvxVI0sc00XBE=
github.com/containerd/console v1.0.0/go.mod h1:8Pf4gM6VEbTNRIT26AyyU7hxdQU3MvAvxVI0sc00XBE=
github.com/containerd/console v1.0.1/go.mod h1:XUsP6YE/mKtz6bxc+I8UiKKTP04qjQL4qcS3XoQ5xkw=
github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 h1:q2hJAaP1k2wIvVRd/hEHD7lacgqrCPS+k8g1MndzfWY=
github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk=
github.com/containerd/containerd v1.3.0-beta.2.0.20190828155532-0293cbd26c69/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA=
github.com/containerd/containerd v1.3.0/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA=
github.com/containerd/containerd v1.3.2/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA=
github.com/containerd/containerd v1.4.0/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA=
github.com/containerd/containerd v1.4.1-0.20201117152358-0edc412565dc/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA=
github.com/containerd/containerd v1.7.12 h1:+KQsnv4VnzyxWcfO9mlxxELaoztsDEjOuCMPAuPqgU0=
github.com/containerd/containerd v1.7.12/go.mod h1:/5OMpE1p0ylxtEUGY8kuCYkDRzJm9NO1TFMWjUpdevk=
github.com/containerd/continuity v0.0.0-20190426062206-aaeac12a7ffc/go.mod h1:GL3xCUCBDV3CZiTSEKksMWbLE66hEyuu9qyDOOqM47Y=
github.com/containerd/continuity v0.0.0-20200710164510-efbc4488d8fe/go.mod h1:cECdGN1O8G9bgKTlLhuPJimka6Xb/Gg7vYzCTNVxhvo=
github.com/containerd/continuity v0.4.3 h1:6HVkalIp+2u1ZLH1J/pYX2oBVXlJZvh1X1A7bEZ9Su8=
github.com/containerd/continuity v0.4.3/go.mod h1:F6PTNCKepoxEaXLQp3wDAjygEnImnZ/7o4JzpodfroQ=
github.com/containerd/fifo v0.0.0-20190226154929-a9fb20d87448/go.mod h1:ODA38xgv3Kuk8dQz2ZQXpnv/UZZUHUCL7pnLehbXgQI=
github.com/containerd/fifo v0.0.0-20200410184934-f15a3290365b/go.mod h1:jPQ2IAeZRCYxpS/Cm1495vGFww6ecHmMk1YJH2Q5ln0=
github.com/containerd/fifo v1.1.0 h1:4I2mbh5stb1u6ycIABlBw9zgtlK8viPI9QkQNRQEEmY=
github.com/containerd/fifo v1.1.0/go.mod h1:bmC4NWMbXlt2EZ0Hc7Fx7QzTFxgPID13eH0Qu+MAb2o=
github.com/containerd/fuse-overlayfs-snapshotter v1.0.6 h1:MWwG/UOQv6J2hvRgKGduhJn5yKZPl4ly+PWMhfPnMzU=
github.com/containerd/fuse-overlayfs-snapshotter v1.0.6/go.mod h1:gfcR4++fMRl37UvYy4Kw6JrQIra1bFFQVVtWEp1oon4=
github.com/containerd/go-cni v1.0.1/go.mod h1:+vUpYxKvAF72G9i1WoDOiPGRtQpqsNW/ZHtSlv++smU=
github.com/containerd/go-cni v1.1.9 h1:ORi7P1dYzCwVM6XPN4n3CbkuOx/NZ2DOqy+SHRdo9rU=
github.com/containerd/go-cni v1.1.9/go.mod h1:XYrZJ1d5W6E2VOvjffL3IZq0Dz6bsVlERHbekNK90PM=
github.com/containerd/go-runc v0.0.0-20180907222934-5a6d9f37cfa3/go.mod h1:IV7qH3hrUgRmyYrtgEeGWJfWbgcHL9CSRruz2Vqcph0=
github.com/containerd/go-runc v0.0.0-20200220073739-7016d3ce2328/go.mod h1:PpyHrqVs8FTi9vpyHwPwiNEGaACDxT/N/pLcvMSRA9g=
github.com/containerd/go-runc v0.0.0-20201020171139-16b287bc67d0/go.mod h1:cNU0ZbCgCQVZK4lgG3P+9tn9/PaJNmoDXPpoJhDR+Ok=
github.com/containerd/go-runc v1.1.0 h1:OX4f+/i2y5sUT7LhmcJH7GYrjjhHa1QI4e8yO0gGleA=
github.com/containerd/go-runc v1.1.0/go.mod h1:xJv2hFF7GvHtTJd9JqTS2UVxMkULUYw4JN5XAUZqH5U=
github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I=
github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo=
github.com/containerd/nydus-snapshotter v0.13.1 h1:5XNkCZ9ivLXCcyx3Jbbfh/fntkcls69uBg0x9VE8zlk=
github.com/containerd/nydus-snapshotter v0.13.1/go.mod h1:XWAz9ytsjBuKPVXDKP3xoMlcSKNsGnjXlEup6DuzUIo=
github.com/containerd/stargz-snapshotter v0.0.0-20201027054423-3a04e4c2c116/go.mod h1:o59b3PCKVAf9jjiKtCc/9hLAd+5p/rfhBfm6aBcTEr4=
github.com/containerd/stargz-snapshotter v0.15.1 h1:fpsP4kf/Z4n2EYnU0WT8ZCE3eiKDwikDhL6VwxIlgeA=
github.com/containerd/stargz-snapshotter v0.15.1/go.mod h1:74D+J1m1RMXytLmWxegXWhtOSRHPWZKpKc2NdK3S+us=
github.com/containerd/stargz-snapshotter/estargz v0.15.1 h1:eXJjw9RbkLFgioVaTG+G/ZW/0kEe2oEKCdS/ZxIyoCU=
github.com/containerd/stargz-snapshotter/estargz v0.15.1/go.mod h1:gr2RNwukQ/S9Nv33Lt6UC7xEx58C+LHRdoqbEKjz1Kk=
github.com/containerd/ttrpc v0.0.0-20190828154514-0e0f228740de/go.mod h1:PvCDdDGpgqzQIzDW1TphrGLssLDZp2GuS+X5DkEJB8o=
github.com/containerd/ttrpc v1.0.1/go.mod h1:UAxOpgT9ziI0gJrmKvgcZivgxOp8iFPSk8httJEt98Y=
github.com/containerd/ttrpc v1.2.2 h1:9vqZr0pxwOF5koz6N0N3kJ0zDHokrcPxIR/ZR2YFtOs=
github.com/containerd/ttrpc v1.2.2/go.mod h1:sIT6l32Ph/H9cvnJsfXM5drIVzTr5A2flTf1G5tYZak=
github.com/containerd/typeurl v0.0.0-20180627222232-a93fcdb778cd/go.mod h1:Cm3kwCdlkCfMSHURc+r6fwoGH6/F1hH3S4sg0rLFWPc=
github.com/containerd/typeurl v1.0.1/go.mod h1:TB1hUtrpaiO88KEK56ijojHS1+NeF0izUACaJW2mdXg=
github.com/containerd/typeurl/v2 v2.1.1 h1:3Q4Pt7i8nYwy2KmQWIw2+1hTvwTE/6w9FqcttATPO/4=
github.com/containerd/typeurl/v2 v2.1.1/go.mod h1:IDp2JFvbwZ31H8dQbEIY7sDl2L3o3HZj1hsSQlywkQ0=
github.com/containernetworking/cni v0.8.0/go.mod h1:LGwApLUm2FpoOfxTDEeq8T9ipbpZ61X79hmU3w8FmsY=
github.com/containernetworking/cni v1.1.2 h1:wtRGZVv7olUHMOqouPpn3cXJWpJgM6+EUl31EQbXALQ=
github.com/containernetworking/cni v1.1.2/go.mod h1:sDpYKmGVENF3s6uvMvGgldDWeG8dMxakj/u+i9ht9vw=
github.com/containernetworking/plugins v1.4.0 h1:+w22VPYgk7nQHw7KT92lsRmuToHvb7wwSv9iTbXzzic=
github.com/containernetworking/plugins v1.4.0/go.mod h1:UYhcOyjefnrQvKvmmyEKsUA+M9Nfn7tqULPpH0Pkcj0=
github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
github.com/coreos/etcd v3.3.13+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
github.com/coreos/go-oidc v2.1.0+incompatible/go.mod h1:CgnwVTmzoESiwO9qyAFEMiHoZ1nMCKZlZ9V6mm3/LKc=
github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
github.com/coreos/go-systemd v0.0.0-20180511133405-39ca1b05acc7/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
github.com/coreos/go-systemd v0.0.0-20181012123002-c6f51f82210d/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
github.com/coreos/go-systemd/v22 v22.0.0/go.mod h1:xO0FLkIi5MaZafQlIrOotqXZ90ih+1atmu1JpKERPPk=
github.com/coreos/go-systemd/v22 v22.1.0/go.mod h1:xO0FLkIi5MaZafQlIrOotqXZ90ih+1atmu1JpKERPPk=
github.com/coreos/go-systemd/v22 v22.4.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
github.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs=
github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
github.com/coreos/pkg v0.0.0-20180108230652-97fdf19511ea/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
github.com/cpuguy83/go-md2man/v2 v2.0.3 h1:qMCsGGgs+MAzDFyp9LpAe1Lqy/fY/qCovCm0qnXZOBM=
github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
github.com/creack/pty v1.1.17/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
github.com/creack/pty v1.1.18 h1:n56/Zwd5o6whRC5PMGretI4IdRLlmBXYNjScPaBgsbY=
github.com/creack/pty v1.1.18/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=
github.com/cyphar/filepath-securejoin v0.2.2/go.mod h1:FpkQEhXnPnOthhzymB7CGsFk2G9VLXONKD9G7QGMM+4=
github.com/cyphar/filepath-securejoin v0.2.4 h1:Ugdm7cg7i6ZK6x3xDF1oEu1nfkyfH53EtKeQYTC3kyg=
github.com/cyphar/filepath-securejoin v0.2.4/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4=
github.com/dave/jennifer v1.7.0 h1:uRbSBH9UTS64yXbh4FrMHfgfY762RD+C7bUPKODpSJE=
github.com/dave/jennifer v1.7.0/go.mod h1:nXbxhEmQfOZhWml3D1cDK5M1FLnMSozpbFN/m3RmGZc=
github.com/davecgh/go-spew v0.0.0-20151105211317-5215b55f46b2/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/denisbrodbeck/machineid v1.0.1 h1:geKr9qtkB876mXguW2X6TU4ZynleN6ezuMSRhl4D7AQ=
github.com/denisbrodbeck/machineid v1.0.1/go.mod h1:dJUwb7PTidGDeYyUBmXZ2GphQBbjJCrnectwCyxcUSI=
github.com/denverdino/aliyungo v0.0.0-20190125010748-a747050bb1ba/go.mod h1:dV8lFg6daOBZbT6/BDGIz6Y3WFGn8juu6G+CQ6LHtl0=
github.com/devigned/tab v0.1.1/go.mod h1:XG9mPq0dFghrYvoBF3xdRrJzSTX1b7IQrvaL9mzjeJY=
github.com/dgrijalva/jwt-go v0.0.0-20170104182250-a601269ab70c/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
github.com/dgryski/trifles v0.0.0-20200323201526-dd97f9abfb48 h1:fRzb/w+pyskVMQ+UbP35JkH8yB7MYb4q/qhBarqZE6g=
github.com/dgryski/trifles v0.0.0-20200323201526-dd97f9abfb48/go.mod h1:if7Fbed8SFyPtHLHbg49SI7NAdJiC5WIA09pe59rfAA=
github.com/dimchansky/utfbom v1.1.0/go.mod h1:rO41eb7gLfo8SF1jd9F8HplJm1Fewwi4mQvIirEdv+8=
github.com/dimchansky/utfbom v1.1.1 h1:vV6w1AhK4VMnhBno/TPVCoK9U/LP0PkLCS9tbxHdi/U=
github.com/dimchansky/utfbom v1.1.1/go.mod h1:SxdoEBH5qIqFocHMyGOXVAybYJdr71b1Q/j0mACtrfE=
github.com/distribution/reference v0.5.0 h1:/FUIFXtfc/x2gpa5/VGfiGLuOIdYa1t65IKK2OFGvA0=
github.com/distribution/reference v0.5.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
github.com/dlclark/regexp2 v1.4.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
github.com/dlclark/regexp2 v1.7.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
github.com/dlclark/regexp2 v1.10.0 h1:+/GIL799phkJqYW+3YbOd8LCcbHzT0Pbo8zl70MHsq0=
github.com/dlclark/regexp2 v1.10.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
github.com/dnaeon/go-vcr v1.0.1/go.mod h1:aBB1+wY4s93YsC3HHjMBMrwTj2R9FHDzUr9KyGc8n1E=
github.com/dnaeon/go-vcr v1.1.0 h1:ReYa/UBrRyQdant9B4fNHGoCNKw6qh6P0fsdGmZpR7c=
github.com/dnaeon/go-vcr v1.1.0/go.mod h1:M7tiix8f0r6mKKJ3Yq/kqU1OYf3MnfmBWVbPx/yU9ko=
github.com/docker/cli v0.0.0-20190925022749-754388324470/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
github.com/docker/cli v0.0.0-20191017083524-a8ff7f821017/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
github.com/docker/cli v20.10.0-beta1.0.20201029214301-1d20b15adc38+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
github.com/docker/cli v25.0.1+incompatible h1:mFpqnrS6Hsm3v1k7Wa/BO23oz0k121MTbTO1lpcGSkU=
github.com/docker/cli v25.0.1+incompatible/go.mod h1:JLrzqnKDaYBop7H2jaqPtU4hHvMKP+vjCwu2uszcLI8=
github.com/docker/distribution v0.0.0-20190905152932-14b96e55d84c/go.mod h1:0+TTO4EOBfRPhZXAeF1Vu+W3hHZ8eLp8PgKVZlcvtFY=
github.com/docker/distribution v2.6.0-rc.1.0.20180327202408-83389a148052+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
github.com/docker/distribution v2.7.1+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
github.com/docker/distribution v2.8.2+incompatible h1:T3de5rq0dB1j30rp0sA2rER+m322EBzniBPB6ZIzuh8=
github.com/docker/distribution v2.8.2+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w=
github.com/docker/docker v0.0.0-20200511152416-a93e9eb0e95c/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
github.com/docker/docker v0.7.3-0.20190327010347-be7ac8be2ae0/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
github.com/docker/docker v1.4.2-0.20180531152204-71cd53e4a197/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
github.com/docker/docker v1.4.2-0.20190924003213-a8608b5b67c7/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
github.com/docker/docker v17.12.0-ce-rc1.0.20200730172259-9f28837c1d93+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
github.com/docker/docker v20.10.0-beta1.0.20201110211921-af34b94a78a1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
github.com/docker/docker v25.0.1+incompatible h1:k5TYd5rIVQRSqcTwCID+cyVA0yRg86+Pcrz1ls0/frA=
github.com/docker/docker v25.0.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
github.com/docker/docker-credential-helpers v0.6.3/go.mod h1:WRaJzqw3CTB9bk10avuGsjVBZsD05qeibJ1/TYlvc0Y=
github.com/docker/docker-credential-helpers v0.8.0 h1:YQFtbBQb4VrpoPxhFuzEBPQ9E16qz5SpHLS+uswaCp8=
github.com/docker/docker-credential-helpers v0.8.0/go.mod h1:UGFXcuoQ5TxPiB54nHOZ32AWRqQdECoh/Mg0AlEYb40=
github.com/docker/go-connections v0.4.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec=
github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c=
github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc=
github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c h1:+pKlWGMw7gf6bQ+oDZB4KHQFypsfjYlq/C4rfL7D3g8=
github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c/go.mod h1:Uw6UezgYA44ePAFQYUehOuCzmy5zmg/+nl2ZfMWGkpA=
github.com/docker/go-metrics v0.0.0-20180209012529-399ea8c73916/go.mod h1:/u0gXw0Gay3ceNrsHubL3BtdOL2fHf93USgMTe0W5dI=
github.com/docker/go-metrics v0.0.1 h1:AgB/0SvBxihN0X8OR4SjsblXkbMvalQ8cjmtKQ2rQV8=
github.com/docker/go-metrics v0.0.1/go.mod h1:cG1hvH2utMXtqgqqYE9plW6lDxS3/5ayHzueweSI3Vw=
github.com/docker/go-units v0.3.3/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
github.com/docker/libnetwork v0.8.0-dev.2.0.20200917202933-d0951081b35f/go.mod h1:93m0aTqz6z+g32wla4l4WxTrdtvBRmVzYRkYvasA5Z8=
github.com/docker/libtrust v0.0.0-20150114040149-fa567046d9b1/go.mod h1:cyGadeNEkKy96OOhEzfZl+yxihPEzKnqJwvfuSUqbZE=
github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96/go.mod h1:Qh8CwZgvJUkLughtfhJv5dyTYa91l1fOUCrgjqmcifM=
github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE=
github.com/dop251/goja v0.0.0-20211022113120-dc8c55024d06/go.mod h1:R9ET47fwRVRPZnOGvHxxhuZcbrMCuiqOz3Rlrh4KSnk=
github.com/dop251/goja v0.0.0-20231027120936-b396bb4c349d h1:wi6jN5LVt/ljaBG4ue79Ekzb12QfJ52L9Q98tl8SWhw=
github.com/dop251/goja v0.0.0-20231027120936-b396bb4c349d/go.mod h1:QMWlm50DNe14hD7t24KEqZuUdC9sOTy8W6XbCU1mlw4=
github.com/dop251/goja_nodejs v0.0.0-20210225215109-d91c329300e7/go.mod h1:hn7BA7c8pLvoGndExHudxTDKZ84Pyvv+90pbBjbTz0Y=
github.com/dop251/goja_nodejs v0.0.0-20211022123610-8dd9abb0616d/go.mod h1:DngW8aVqWbuLRMHItjPUyqdj+HWPvnQe8V8y1nDpIbM=
github.com/dschmidt/go-layerfs v0.1.0 h1:jE6aHDfjNzS/31DS48th6EkmELwTa1Uf+aO4jRkBs3U=
github.com/dschmidt/go-layerfs v0.1.0/go.mod h1:m62aff0hn23Q/tQBRiNSeLD7EUuimDvsuCvCpzBr3Gw=
github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
github.com/elazarl/goproxy v0.0.0-20170405201442-c4fc26588b6e/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc=
github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc=
github.com/elazarl/goproxy v0.0.0-20230808193330-2592e75ae04a h1:mATvB/9r/3gvcejNsXKSkQ6lcIaNec2nyfOdlTBR2lU=
github.com/elazarl/goproxy v0.0.0-20230808193330-2592e75ae04a/go.mod h1:Ro8st/ElPeALwNFlcTpWmkr6IoMFfkjXAvTHpevnDsM=
github.com/emicklei/go-restful v0.0.0-20170410110728-ff4f55a20633/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs=
github.com/emicklei/go-restful v2.9.5+incompatible/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs=
github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po=
github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE=
github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
github.com/envoyproxy/protoc-gen-validate v1.0.2 h1:QkIBuU5k+x7/QXPvPPnWXWlCdaBFApVqftFV6k087DA=
github.com/envoyproxy/protoc-gen-validate v1.0.2/go.mod h1:GpiZQP3dDbg4JouG/NNS7QWXpgx6x8QiMKdmN72jogE=
github.com/evanphx/json-patch v4.2.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
github.com/felixge/httpsnoop v1.0.1/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
github.com/fogleman/ease v0.0.0-20170301025033-8da417bf1776 h1:VRIbnDWRmAh5yBdz+J6yFMF5vso1It6vn+WmM/5l7MA=
github.com/fogleman/ease v0.0.0-20170301025033-8da417bf1776/go.mod h1:9wvnDu3YOfxzWM9Cst40msBF1C2UdQgDv962oTxSuMs=
github.com/fortytw2/leaktest v1.2.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g=
github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g=
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
github.com/garyburd/redigo v0.0.0-20150301180006-535138d7bcd7/go.mod h1:NR3MbYisc3/PwhQ00EMzDiPmrwpPxAn5GI05/YaO1SY=
github.com/ghodss/yaml v0.0.0-20150909031657-73d445a93680/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
github.com/gliderlabs/ssh v0.3.5 h1:OcaySEmAQJgyYcArR+gGGTHCyE7nvhEMTlYY+Dp8CpY=
github.com/gliderlabs/ssh v0.3.5/go.mod h1:8XB4KraRrX39qHhT6yxPsHedjA08I/uBVwj4xC+/+z4=
github.com/go-critic/go-critic v0.4.1/go.mod h1:7/14rZGnZbY6E38VEGk2kVhoq6itzc1E68facVDK23g=
github.com/go-critic/go-critic v0.4.3/go.mod h1:j4O3D4RoIwRqlZw5jJpx0BNfXWWbpcJoKu5cYSe4YmQ=
github.com/go-fonts/liberation v0.3.1 h1:9RPT2NhUpxQ7ukUvz3jeUckmN42T9D9TpjtQcqK/ceM=
github.com/go-fonts/liberation v0.3.1/go.mod h1:jdJ+cqF+F4SUL2V+qxBth8fvBpBDS7yloUL5Fi8GTGY=
github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI=
github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic=
github.com/go-git/go-billy/v5 v5.5.0 h1:yEY4yhzCDuMGSv83oGxiBotRzhwhNr8VZyphhiu+mTU=
github.com/go-git/go-billy/v5 v5.5.0/go.mod h1:hmexnoNsr2SJU1Ju67OaNz5ASJY3+sHgFRpCtpDCKow=
github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4=
github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII=
github.com/go-git/go-git/v5 v5.11.0 h1:XIZc1p+8YzypNr34itUfSvYJcv+eYdTnTvOZ2vD3cA4=
github.com/go-git/go-git/v5 v5.11.0/go.mod h1:6GFcX2P3NM7FPBfpePbpLd21XxsgdAt+lKqXmCUiUCY=
github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
github.com/go-ini/ini v1.25.4/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
github.com/go-kit/log v0.2.0/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0=
github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU=
github.com/go-kit/log v0.2.1/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0=
github.com/go-latex/latex v0.0.0-20230307184459-12ec69307ad9 h1:NxXI5pTAtpEaU49bpLpQoDsu1zrteW/vxzTz8Cd2UAs=
github.com/go-latex/latex v0.0.0-20230307184459-12ec69307ad9/go.mod h1:gWuR/CrFDDeVRFQwHPvsv9soJVB/iqymhuZQuJ3a9OM=
github.com/go-lintpack/lintpack v0.5.2/go.mod h1:NwZuYi2nUHho8XEIZ6SIxihrnPoqBTDqfpXvXAN0sXM=
github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
github.com/go-logfmt/logfmt v0.5.1 h1:otpy5pqBCBZ1ng9RQ0dPu4PN7ba75Y/aA+UpowDyNVA=
github.com/go-logfmt/logfmt v0.5.1/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas=
github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU=
github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-logr/logr v1.3.0 h1:2y3SDp0ZXuc6/cjLSZ+Q3ir+QB9T/iG5yYRXqsagWSY=
github.com/go-logr/logr v1.3.0/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8=
github.com/go-openapi/jsonpointer v0.0.0-20160704185906-46af16f9f7b1/go.mod h1:+35s3my2LFTysnkMfxsJBAMHj/DoqoB9knIWoYG/Vk0=
github.com/go-openapi/jsonpointer v0.19.2/go.mod h1:3akKfEdA7DF1sugOqz1dVQHBcuDBPKZGEoHC/NkiQRg=
github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg=
github.com/go-openapi/jsonreference v0.0.0-20160704190145-13c6e3589ad9/go.mod h1:W3Z9FmVs9qj+KR4zFKmDPGiLdk1D9Rlm7cyMvf57TTg=
github.com/go-openapi/jsonreference v0.19.2/go.mod h1:jMjeRr2HHw6nAVajTXJ4eiUwohSTlpa0o73RUL1owJc=
github.com/go-openapi/jsonreference v0.19.3/go.mod h1:rjx6GuL8TTa9VaixXglHmQmIL98+wF9xc8zWvFonSJ8=
github.com/go-openapi/spec v0.0.0-20160808142527-6aced65f8501/go.mod h1:J8+jY1nAiCcj+friV/PDoE1/3eeccG9LYBs0tYvLOWc=
github.com/go-openapi/spec v0.19.3/go.mod h1:FpwSN1ksY1eteniUU7X0N/BgJ7a4WvBFVA8Lj9mJglo=
github.com/go-openapi/swag v0.0.0-20160704191624-1d0bd113de87/go.mod h1:DXUve3Dpr1UfpPtxFw+EFuQ41HhCWZfha5jSVRG7C7I=
github.com/go-openapi/swag v0.19.2/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk=
github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk=
github.com/go-pdf/fpdf v0.8.0 h1:IJKpdaagnWUeSkUFUjTcSzTppFxmv8ucGQyNPQWxYOQ=
github.com/go-pdf/fpdf v0.8.0/go.mod h1:gfqhcNwXrsd3XYKte9a7vM3smvU/jB4ZRDrmWSxpfdc=
github.com/go-sourcemap/sourcemap v2.1.3+incompatible h1:W1iEw64niKVGogNgBN3ePyLFfuisuzeidWPMPWmECqU=
github.com/go-sourcemap/sourcemap v2.1.3+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg=
github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
github.com/go-toolsmith/astcast v1.0.0/go.mod h1:mt2OdQTeAQcY4DQgPSArJjHCcOwlX+Wl/kwN+LbLGQ4=
github.com/go-toolsmith/astcopy v1.0.0/go.mod h1:vrgyG+5Bxrnz4MZWPF+pI4R8h3qKRjjyvV/DSez4WVQ=
github.com/go-toolsmith/astequal v0.0.0-20180903214952-dcb477bfacd6/go.mod h1:H+xSiq0+LtiDC11+h1G32h7Of5O3CYFJ99GVbS5lDKY=
github.com/go-toolsmith/astequal v1.0.0/go.mod h1:H+xSiq0+LtiDC11+h1G32h7Of5O3CYFJ99GVbS5lDKY=
github.com/go-toolsmith/astfmt v0.0.0-20180903215011-8f8ee99c3086/go.mod h1:mP93XdblcopXwlyN4X4uodxXQhldPGZbcEJIimQHrkg=
github.com/go-toolsmith/astfmt v1.0.0/go.mod h1:cnWmsOAuq4jJY6Ct5YWlVLmcmLMn1JUPuQIHCY7CJDw=
github.com/go-toolsmith/astinfo v0.0.0-20180906194353-9809ff7efb21/go.mod h1:dDStQCHtmZpYOmjRP/8gHHnCCch3Zz3oEgCdZVdtweU=
github.com/go-toolsmith/astp v0.0.0-20180903215135-0af7e3c24f30/go.mod h1:SV2ur98SGypH1UjcPpCatrV5hPazG6+IfNHbkDXBRrk=
github.com/go-toolsmith/astp v1.0.0/go.mod h1:RSyrtpVlfTFGDYRbrjyWP1pYu//tSFcvdYrA8meBmLI=
github.com/go-toolsmith/pkgload v0.0.0-20181119091011-e9e65178eee8/go.mod h1:WoMrjiy4zvdS+Bg6z9jZH82QXwkcgCBX6nOfnmdaHks=
github.com/go-toolsmith/pkgload v1.0.0/go.mod h1:5eFArkbO80v7Z0kdngIxsRXRMTaX4Ilcwuh3clNrQJc=
github.com/go-toolsmith/strparse v1.0.0/go.mod h1:YI2nUKP9YGZnL/L1/DLFBfixrcjslWct4wyljWhSRy8=
github.com/go-toolsmith/typep v1.0.0/go.mod h1:JSQCQMUPdRlMZFswiq3TGpNp1GMktqkR2Ns5AIQkATU=
github.com/go-toolsmith/typep v1.0.2/go.mod h1:JSQCQMUPdRlMZFswiq3TGpNp1GMktqkR2Ns5AIQkATU=
github.com/go-xmlfmt/xmlfmt v0.0.0-20191208150333-d5b6f63a941b/go.mod h1:aUCEOzzezBEjDBbFBoSiya/gduyIiWYRP6CnSFIV8AM=
github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=
github.com/godbus/dbus v0.0.0-20190422162347-ade71ed3457e/go.mod h1:bBOAhwG1umN6/6ZUMtDFBMQR8jRg9O75tm9K00oMsK4=
github.com/godbus/dbus/v5 v5.0.3/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/gofrs/flock v0.0.0-20190320160742-5135e617513b/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
github.com/gofrs/flock v0.7.3/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw=
github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
github.com/gogo/googleapis v1.2.0/go.mod h1:Njal3psf3qN6dwBtQfUmBZh2ybovJ0tlu3o/AC7HYjU=
github.com/gogo/googleapis v1.3.2/go.mod h1:5YRNX2z1oM5gXdAkurHa942MDgEJyk02w4OecKY87+c=
github.com/gogo/googleapis v1.4.1 h1:1Yx4Myt7BxzvUr5ldGSbwYiZG6t9wGBZ+8/fX3Wvtq0=
github.com/gogo/googleapis v1.4.1/go.mod h1:2lpHqI5OcWCtVElxXnPt+s8oJvMpySlOyM6xDCrzib4=
github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
github.com/gogo/protobuf v1.2.2-0.20190723190241-65acae22fc9d/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
github.com/gogo/protobuf v1.3.0/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
github.com/gogo/status v1.0.3/go.mod h1:SavQ51ycCLnc7dGyJxp8YAmudx8xqiVrRf+6IXRsugc=
github.com/golang-jwt/jwt/v4 v4.1.0/go.mod h1:/xlHOz8bRuivTWchD4jCa+NbatV+wEUSzwAxVc6locg=
github.com/golang-jwt/jwt/v4 v4.4.2 h1:rcc4lwaZgFMCZ5jxF9ABolDcIHdBytAFgqFPbSJQAYs=
github.com/golang-jwt/jwt/v4 v4.4.2/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
github.com/golang/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E=
github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8=
github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
github.com/golang/protobuf v0.0.0-20161109072736-4bd1920723d7/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM=
github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/golangci/check v0.0.0-20180506172741-cfe4005ccda2/go.mod h1:k9Qvh+8juN+UKMCS/3jFtGICgW8O96FVaZsaxdzDkR4=
github.com/golangci/dupl v0.0.0-20180902072040-3e9179ac440a/go.mod h1:ryS0uhF+x9jgbj/N71xsEqODy9BN81/GonCZiOzirOk=
github.com/golangci/errcheck v0.0.0-20181223084120-ef45e06d44b6/go.mod h1:DbHgvLiFKX1Sh2T1w8Q/h4NAI8MHIpzCdnBUDTXU3I0=
github.com/golangci/go-misc v0.0.0-20180628070357-927a3d87b613/go.mod h1:SyvUF2NxV+sN8upjjeVYr5W7tyxaT1JVtvhKhOn2ii8=
github.com/golangci/goconst v0.0.0-20180610141641-041c5f2b40f3/go.mod h1:JXrF4TWy4tXYn62/9x8Wm/K/dm06p8tCKwFRDPZG/1o=
github.com/golangci/gocyclo v0.0.0-20180528134321-2becd97e67ee/go.mod h1:ozx7R9SIwqmqf5pRP90DhR2Oay2UIjGuKheCBCNwAYU=
github.com/golangci/gocyclo v0.0.0-20180528144436-0a533e8fa43d/go.mod h1:ozx7R9SIwqmqf5pRP90DhR2Oay2UIjGuKheCBCNwAYU=
github.com/golangci/gofmt v0.0.0-20190930125516-244bba706f1a/go.mod h1:9qCChq59u/eW8im404Q2WWTrnBUQKjpNYKMbU4M7EFU=
github.com/golangci/golangci-lint v1.23.7/go.mod h1:g/38bxfhp4rI7zeWSxcdIeHTQGS58TCak8FYcyCmavQ=
github.com/golangci/golangci-lint v1.27.0/go.mod h1:+eZALfxIuthdrHPtfM7w/R3POJLjHDfJJw8XZl9xOng=
github.com/golangci/ineffassign v0.0.0-20190609212857-42439a7714cc/go.mod h1:e5tpTHCfVze+7EpLEozzMB3eafxo2KT5veNg1k6byQU=
github.com/golangci/lint-1 v0.0.0-20191013205115-297bf364a8e0/go.mod h1:66R6K6P6VWk9I95jvqGxkqJxVWGFy9XlDwLwVz1RCFg=
github.com/golangci/maligned v0.0.0-20180506175553-b1d89398deca/go.mod h1:tvlJhZqDe4LMs4ZHD0oMUlt9G2LWuDGoisJTBzLMV9o=
github.com/golangci/misspell v0.0.0-20180809174111-950f5d19e770/go.mod h1:dEbvlSfYbMQDtrpRMQU675gSDLDNa8sCPPChZ7PhiVA=
github.com/golangci/misspell v0.3.5/go.mod h1:dEbvlSfYbMQDtrpRMQU675gSDLDNa8sCPPChZ7PhiVA=
github.com/golangci/prealloc v0.0.0-20180630174525-215b22d4de21/go.mod h1:tf5+bzsHdTM0bsB7+8mt0GUMvjCgwLpTapNZHU8AajI=
github.com/golangci/revgrep v0.0.0-20180526074752-d9c87f5ffaf0/go.mod h1:qOQCunEYvmd/TLamH+7LlVccLvUH5kZNhbCgTHoBbp4=
github.com/golangci/revgrep v0.0.0-20180812185044-276a5c0a1039/go.mod h1:qOQCunEYvmd/TLamH+7LlVccLvUH5kZNhbCgTHoBbp4=
github.com/golangci/unconvert v0.0.0-20180507085042-28b1c447d1f4/go.mod h1:Izgrg8RkN3rCIMLGE9CyYmU9pY2Jer6DgANEnZ/L/cQ=
github.com/google/btree v0.0.0-20180124185431-e89373fe6b4a/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
github.com/google/crfs v0.0.0-20191108021818-71d77da419c9/go.mod h1:etGhoOqfwPkooV6aqoX3eBGQOJblqdoc9XvWOeuxpPw=
github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE=
github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/go-containerregistry v0.0.0-20191010200024-a3d713f9b7f8/go.mod h1:KyKXa9ciM8+lgMXwOVsXi7UxGrsf9mM61Mzs+xKUrKE=
github.com/google/go-containerregistry v0.1.2/go.mod h1:GPivBPgdAyd2SU+vf6EpsgOtWDuPqjW0hJZt4rNdTZ4=
github.com/google/go-containerregistry v0.19.0 h1:uIsMRBV7m/HDkDxE/nXMnv1q+lOOSPlQ/ywc5JbB8Ic=
github.com/google/go-containerregistry v0.19.0/go.mod h1:u0qB2l7mvtWVR5kNcbFIhFY1hLbf8eeGapA+vbFDCtQ=
github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ=
github.com/google/go-github/v28 v28.1.1/go.mod h1:bsqJWQX05omyWVmc00nEUql9mhQyv38lDZ8kPZcQVoM=
github.com/google/go-github/v50 v50.2.0 h1:j2FyongEHlO9nxXLc+LP3wuBSVU9mVxfpdYUexMpIfk=
github.com/google/go-github/v50 v50.2.0/go.mod h1:VBY8FB6yPIjrtKhozXv4FQupxKLS6H4m6xFZlT43q8Q=
github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
github.com/google/go-replayers/grpcreplay v0.1.0/go.mod h1:8Ig2Idjpr6gifRd6pNVggX6TC1Zw6Jx74AKp7QNH2QE=
github.com/google/go-replayers/httpreplay v0.1.0/go.mod h1:YKZViNhiGgqdBlUbI2MwGpq4pXxNmhJLPHQ7cv2b5no=
github.com/google/gofuzz v0.0.0-20161122191042-44d81051d367/go.mod h1:HP5RmnzzSNb993RKQDq4+1A4ia9nllfqcQFTQJedwGI=
github.com/google/gofuzz v0.0.0-20170612174753-24818f796faf/go.mod h1:HP5RmnzzSNb993RKQDq4+1A4ia9nllfqcQFTQJedwGI=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/google/gofuzz v1.1.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
github.com/google/martian v2.1.1-0.20190517191504-25dcb96d9e51+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
github.com/google/martian/v3 v3.2.1/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk=
github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
github.com/google/pprof v0.0.0-20230207041349-798e818bf904/go.mod h1:uglQLonpP8qtYCYyzA+8c/9qtqgA3qsXGYqCPKARAFg=
github.com/google/pprof v0.0.0-20231101202521-4ca4178f5c7a h1:fEBsGL/sjAuJrgah5XqmmYsTLzJp/TO9Lhy39gkverk=
github.com/google/pprof v0.0.0-20231101202521-4ca4178f5c7a/go.mod h1:czg5+yv1E0ZGTi6S6vVK1mke0fV+FaUhNGcd6VRS9Ik=
github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
github.com/google/rpmpack v0.0.0-20191226140753-aa36bfddb3a0/go.mod h1:RaTPr0KUf2K7fnZYLNDrr8rxAamWs3iNywJLtQ2AzBg=
github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4=
github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ=
github.com/google/subcommands v1.0.1/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk=
github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/google/wire v0.3.0/go.mod h1:i1DMg/Lu8Sz5yYl25iOdmc5CT5qusaa+zmRWs16741s=
github.com/google/wire v0.4.0/go.mod h1:ngWDr9Qvq3yZA10YrxfyGELY/AFWGVpy9c1LTRi1EoU=
github.com/googleapis/enterprise-certificate-proxy v0.0.0-20220520183353-fd19c99a87aa/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8=
github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
github.com/googleapis/gax-go v2.0.2+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0=
github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM=
github.com/googleapis/gax-go/v2 v2.2.0/go.mod h1:as02EH8zWkzwUoLbBaFeQ+arQaj/OthfcblKl4IGNaM=
github.com/googleapis/gax-go/v2 v2.3.0/go.mod h1:b8LNqSzNabLiUpXKkY7HAR5jr6bIT99EXz9pXxye9YM=
github.com/googleapis/gax-go/v2 v2.4.0/go.mod h1:XOTVJ59hdnfJLIP/dh8n5CGryZR2LxK9wbMD5+iXC6c=
github.com/googleapis/gnostic v0.0.0-20170729233727-0c5108395e2d/go.mod h1:sJBsCZ4ayReDTBIg8b9dl28c5xFWyhBTVRp3pOg5EKY=
github.com/googleapis/gnostic v0.2.2/go.mod h1:sJBsCZ4ayReDTBIg8b9dl28c5xFWyhBTVRp3pOg5EKY=
github.com/googleapis/gnostic v0.4.1/go.mod h1:LRhVm6pbyptWbWbuZ38d1eyptfvIytN3ir6b65WBswg=
github.com/googleapis/go-type-adapters v1.0.0/go.mod h1:zHW75FOG2aur7gAO2B+MLby+cLsWGBF62rFAi7WjWO4=
github.com/gookit/color v1.2.4/go.mod h1:AhIE+pS6D4Ql0SQWbBeXPHw7gY0/sjHoA4s/n1KB7xg=
github.com/gophercloud/gophercloud v0.1.0/go.mod h1:vxM41WHh5uqHVBMZHzuwNOHh8XEoIEcSTewFxm1c5g8=
github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
github.com/goreleaser/goreleaser v0.136.0/go.mod h1:wiKrPUeSNh6Wu8nUHxZydSOVQ/OZvOaO7DTtFqie904=
github.com/goreleaser/nfpm v1.2.1/go.mod h1:TtWrABZozuLOttX2uDlYyECfQX7x5XYkVxhjYcR6G9w=
github.com/goreleaser/nfpm v1.3.0/go.mod h1:w0p7Kc9TAUgWMyrub63ex3M2Mgw88M4GZXoTq5UCb40=
github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
github.com/gorilla/handlers v0.0.0-20150720190736-60c7bfde3e33/go.mod h1:Qkdc/uu4tH4g6mTK6auzZ766c4CA0Ng8+o/OAirnOIQ=
github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
github.com/gorilla/mux v1.7.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
github.com/gostaticanalysis/analysisutil v0.0.0-20190318220348-4088753ea4d3/go.mod h1:eEOZF4jCKGi+aprrirO9e7WKB3beBRtWgqGunKl6pKE=
github.com/gostaticanalysis/analysisutil v0.0.3/go.mod h1:eEOZF4jCKGi+aprrirO9e7WKB3beBRtWgqGunKl6pKE=
github.com/gotestyourself/gotestyourself v2.2.0+incompatible/go.mod h1:zZKM6oeNM8k+FRljX1mnzVYeS8wiGgQyvST1/GafPbY=
github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de4/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
github.com/grpc-ecosystem/go-grpc-middleware v1.2.0/go.mod h1:mJzapYve32yjrKlk9GbyCZHuPgZsrbyIbyKhSzOpg6s=
github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 h1:+9834+KizmvFV7pXQGSXQTsaWhq2GjuNUt0aUU0YBYw=
github.com/grpc-ecosystem/go-grpc-middleware v1.3.0/go.mod h1:z0ButlSOZa5vEBq9m2m2hlwIgKw+rp3sdCBRoJY+30Y=
github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
github.com/grpc-ecosystem/grpc-gateway v1.5.0/go.mod h1:RSKVYQBd5MCa4OVpNdGskqpgL2+G+NZTnrVHpWWfpdw=
github.com/grpc-ecosystem/grpc-gateway v1.6.2/go.mod h1:RSKVYQBd5MCa4OVpNdGskqpgL2+G+NZTnrVHpWWfpdw=
github.com/grpc-ecosystem/grpc-gateway v1.8.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
github.com/grpc-ecosystem/grpc-gateway v1.9.2/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
github.com/grpc-ecosystem/grpc-gateway/v2 v2.18.1 h1:6UKoz5ujsI55KNpsJH3UwCq3T8kKbZwNZBNPuTTje8U=
github.com/grpc-ecosystem/grpc-gateway/v2 v2.18.1/go.mod h1:YvJ2f6MplWDhfxiUC3KpyTy76kYUZA4W3pTv/wdKQ9Y=
github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645/go.mod h1:6iZfnjpejD4L/4DwD7NryNaJyCQdzwWwH2MWhCA90Kw=
github.com/hanwen/go-fuse v1.0.0/go.mod h1:unqXarDXqzAk0rt98O2tVndEPIpUgLD9+rwFisZH3Ok=
github.com/hanwen/go-fuse/v2 v2.0.3/go.mod h1:0EQM6aH2ctVpvZ6a+onrQ/vaykxh2GH7hy3e13vzTUY=
github.com/hanwen/go-fuse/v2 v2.4.0 h1:12OhD7CkXXQdvxG2osIdBQLdXh+nmLXY9unkUIe/xaU=
github.com/hanwen/go-fuse/v2 v2.4.0/go.mod h1:xKwi1cF7nXAOBCXujD5ie0ZKsxc8GGSA1rlMJc+8IJs=
github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q=
github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8=
github.com/hashicorp/errwrap v0.0.0-20141028054710-7554cd9344ce/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=
github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48=
github.com/hashicorp/go-hclog v0.9.2/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ=
github.com/hashicorp/go-hclog v1.2.0 h1:La19f8d7WIlm4ogzNHB0JGqs5AUDAZ2UfCY4sJXcJdM=
github.com/hashicorp/go-hclog v1.2.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ=
github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
github.com/hashicorp/go-immutable-radix v1.3.1 h1:DKHmCUm2hRBK510BaiZlwvpD40f8bJFeZnpfm2KLowc=
github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
github.com/hashicorp/go-multierror v0.0.0-20161216184304-ed905158d874/go.mod h1:JMRHfdO9jKNzS/+BTlxCjKNQHg/jZAft8U7LloJvN7I=
github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
github.com/hashicorp/go-retryablehttp v0.6.4/go.mod h1:vAew36LZh98gCBJNLH42IQ1ER/9wtLZZ8meHqQvEYWY=
github.com/hashicorp/go-retryablehttp v0.6.6/go.mod h1:vAew36LZh98gCBJNLH42IQ1ER/9wtLZZ8meHqQvEYWY=
github.com/hashicorp/go-retryablehttp v0.7.4 h1:ZQgVdpTdAL7WpMIwLzCfbalOcSUdkDZnpUv3/+BxzFA=
github.com/hashicorp/go-retryablehttp v0.7.4/go.mod h1:Jy/gPYAdjqffZ/yFGCFV2doI5wjtH1ewM9u8iYVjtX8=
github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU=
github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU=
github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4=
github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
github.com/hashicorp/go-uuid v1.0.1 h1:fv1ep09latC32wFoVwnqcnKJGnMSdBanPczbHAYm1BE=
github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90=
github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
github.com/hashicorp/golang-lru v0.5.3/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc=
github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
github.com/hashicorp/golang-lru/v2 v2.0.3 h1:kmRrRLlInXvng0SmLxmQpQkpbYAvcXm7NPDrgxJa9mE=
github.com/hashicorp/golang-lru/v2 v2.0.3/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=
github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I=
github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
github.com/hashicorp/uuid v0.0.0-20160311170451-ebb0a03e909c/go.mod h1:fHzc09UnyJyqyW+bFuq864eh+wC7dj65aXmXLRe5to0=
github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
github.com/iancoleman/strcase v0.3.0 h1:nTXanmYxhfFAMjZL34Ov6gkzEsSJZ5DbhxWjvSASxEI=
github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho=
github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
github.com/ianlancetaylor/demangle v0.0.0-20220319035150-800ac71e25c2/go.mod h1:aYm2/VgdVmcIU8iMfdMvDMsRAQjcfZSKFby6HOFvi/w=
github.com/imdario/mergo v0.3.5/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
github.com/imdario/mergo v0.3.8/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
github.com/imdario/mergo v0.3.9/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
github.com/in-toto/in-toto-golang v0.5.0 h1:hb8bgwr0M2hGdDsLjkJ3ZqJ8JFLL/tgYdAxF/XEFBbY=
github.com/in-toto/in-toto-golang v0.5.0/go.mod h1:/Rq0IZHLV7Ku5gielPT4wPHJfH1GdHMCq8+WPxw8/BE=
github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
github.com/ishidawataru/sctp v0.0.0-20191218070446-00ab2ac2db07/go.mod h1:co9pwDoBCm1kGxawmb4sPq0cSIOOWNPT4KnHotMP1Zg=
github.com/jackpal/gateway v1.0.7 h1:7tIFeCGmpyrMx9qvT0EgYUi7cxVW48a0mMvnIL17bPM=
github.com/jackpal/gateway v1.0.7/go.mod h1:aRcO0UFKt+MgIZmRmvOmnejdDT4Y1DNiNOsSd1AcIbA=
github.com/jaguilar/vt100 v0.0.0-20150826170717-2703a27b14ea/go.mod h1:QMdK4dGB3YhEW2BmA1wgGpPYI3HZy/5gD705PXKUVSg=
github.com/jarcoal/httpmock v1.0.5/go.mod h1:ATjnClrvW/3tijVmpL/va5Z3aAyGvqU3gCT8nX0Txik=
github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
github.com/jellevandenhooff/dkim v0.0.0-20150330215556-f50fe3d243e1/go.mod h1:E0B/fFc00Y+Rasa88328GlI/XbtyysCtTHZS8h7IrBU=
github.com/jingyugao/rowserrcheck v0.0.0-20191204022205-72ab7603b68a/go.mod h1:xRskid8CManxVta/ALEhJha/pweKBaVG6fWgc0yH25s=
github.com/jirfag/go-printf-func-name v0.0.0-20191110105641-45db9963cdd3/go.mod h1:HEWGJkRDzjJY2sqdDwxccsGicWEf9BQOZsq2tV+xzM0=
github.com/jirfag/go-printf-func-name v0.0.0-20200119135958-7558a9eaa5af/go.mod h1:HEWGJkRDzjJY2sqdDwxccsGicWEf9BQOZsq2tV+xzM0=
github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
github.com/jmespath/go-jmespath v0.0.0-20160803190731-bd40a432e4c7/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
github.com/jmespath/go-jmespath v0.3.0/go.mod h1:9QtRXoHjLGCJ5IBSaohpXITPlowMeeYCZ7fLUTSywik=
github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8=
github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
github.com/jmoiron/sqlx v1.2.1-0.20190826204134-d7d95172beb5/go.mod h1:1FEQNm3xlJgrMD+FBdI9+xvCksHtbpVBBw5dYhBSsks=
github.com/joefitzgerald/rainbow-reporter v0.1.0/go.mod h1:481CNgqmVHQZzdIbN52CupLJyoVwB10FQ/IQlF1pdL8=
github.com/joho/godotenv v1.3.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg=
github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
github.com/jonboulle/clockwork v0.4.0 h1:p4Cf1aMWXnXAUh8lVfewRBx1zaTSYKrKMF2g3ST4RZ4=
github.com/jonboulle/clockwork v0.4.0/go.mod h1:xgRqUGwRcjKCO1vbZUEtSLrqKoPSsUpK7fnezOII0kc=
github.com/jpillora/backoff v0.0.0-20180909062703-3050d21c67d7/go.mod h1:2iMrUgbbvHEiQClaW2NsSzMyGHqN+rDFqY705q49KG0=
github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
github.com/json-iterator/go v0.0.0-20180612202835-f2b4162afba3/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
github.com/json-iterator/go v0.0.0-20180701071628-ab8a2e0c74be/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
github.com/juju/ansiterm v1.0.0 h1:gmMvnZRq7JZJx6jkfSq9/+2LMrVEwGwt7UR6G+lmDEg=
github.com/juju/ansiterm v1.0.0/go.mod h1:PyXUpnI3olx3bsPcHt98FGPX/KCFZ1Fi+hw1XLI6384=
github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4=
github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
github.com/klauspost/compress v1.4.0/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
github.com/klauspost/compress v1.4.1/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
github.com/klauspost/compress v1.17.4 h1:Ej5ixsIri7BrIjBkRZLTo6ghwrEtHFk7ijlczPW4fZ4=
github.com/klauspost/compress v1.17.4/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM=
github.com/klauspost/cpuid v0.0.0-20180405133222-e7e905edc00e/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
github.com/klauspost/cpuid v1.2.0/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
github.com/klauspost/cpuid/v2 v2.0.9 h1:lgaqFMSdTdQYdZ04uHyN2d/eKdOMyi2YLSvlQIBFYa4=
github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/pty v1.1.3/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/pty v1.1.5/go.mod h1:9r2w37qlBe7rQ6e1fg1S/9xpWHSnaqNdHD3WcMdbPDA=
github.com/kr/pty v1.1.8/go.mod h1:O1sed60cT9XZ5uDucP5qwvh+TE3NnUj51EiZO/lmSfw=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348/go.mod h1:B69LEHPfb2qLo0BaaOLcbitczOKLWTsrBG9LczfCD4k=
github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
github.com/lib/pq v1.1.1/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
github.com/logrusorgru/aurora v0.0.0-20181002194514-a7b3b318ed4e/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4=
github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
github.com/lunixbochs/vtclean v1.0.0 h1:xu2sLAri4lGiovBDQKxl5mrXyESr3gUr5m5SM5+LVb8=
github.com/lunixbochs/vtclean v1.0.0/go.mod h1:pHhQNgMf3btfWnGBVipUOjRYhoOsdGqdm/+2c2E2WMI=
github.com/mackerelio/go-osstat v0.2.4 h1:qxGbdPkFo65PXOb/F/nhDKpF2nGmGaCFDLXoZjJTtUs=
github.com/mackerelio/go-osstat v0.2.4/go.mod h1:Zy+qzGdZs3A9cuIqmgbJvwbmLQH9dJvtio5ZjJTbdlQ=
github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
github.com/mailru/easyjson v0.0.0-20160728113105-d5b7844b561a/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
github.com/mailru/easyjson v0.7.0/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs=
github.com/maratori/testpackage v1.0.1/go.mod h1:ddKdw+XG0Phzhx8BFDTKgpWP4i7MpApTE5fXSKAqwDU=
github.com/marstr/guid v1.1.0/go.mod h1:74gB1z2wpxxInTG6yaqA7KrtM0NZ+RbrcqDvYHefzho=
github.com/matoous/godox v0.0.0-20190911065817-5d6d842e92eb/go.mod h1:1BELzlh859Sh1c6+90blK8lbYy0kwQf1bYlBhBysy1s=
github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-colorable v0.1.10/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
github.com/mattn/go-ieproxy v0.0.0-20190610004146-91bb50d98149/go.mod h1:31jz6HNzdxOmlERGGEc4v/dMssOfmp2p5bT/okiKFFc=
github.com/mattn/go-ieproxy v0.0.0-20190702010315-6dee0af9227d/go.mod h1:31jz6HNzdxOmlERGGEc4v/dMssOfmp2p5bT/okiKFFc=
github.com/mattn/go-ieproxy v0.0.1/go.mod h1:pYabZ6IHcRpFh7vIaLfK7rdcWgFEb3SFJ6/gNWuh88E=
github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
github.com/mattn/go-shellwords v1.0.10/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y=
github.com/mattn/go-sqlite3 v1.9.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
github.com/mattn/go-zglob v0.0.1/go.mod h1:9fxibJccNxU2cnpIKLRRFA7zX7qhkJIQWBb449FYHOo=
github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw=
github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo=
github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
github.com/maxbrunsfeld/counterfeiter/v6 v6.2.2/go.mod h1:eD9eIE7cdwcMi9rYluz88Jz2VyhSmden33/aXg4oVIY=
github.com/mazznoer/csscolorparser v0.1.3 h1:vug4zh6loQxAUxfU1DZEu70gTPufDPspamZlHAkKcxE=
github.com/mazznoer/csscolorparser v0.1.3/go.mod h1:Aj22+L/rYN/Y6bj3bYqO3N6g1dtdHtGfQ32xZ5PJQic=
github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
github.com/mitchellh/go-ps v0.0.0-20190716172923-621e5597135b/go.mod h1:r1VsdOzOPt1ZSrGZWFoNhsAedKnEd6r9Np1+5blZCWk=
github.com/mitchellh/go-spdx v0.1.0 h1:50JnVzkL3kWreQ5Qb4Pi3Qx9e+bbYrt8QglJDpfeBEs=
github.com/mitchellh/go-spdx v0.1.0/go.mod h1:FFi4Cg1fBuN/JCtPtP8PEDmcBjvO3gijQVl28YjIBVQ=
github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg=
github.com/mitchellh/hashstructure v1.0.0/go.mod h1:QjSHrPWS+BGUVBYkbTZWEnOh3G1DutKwClXU/ABz6AQ=
github.com/mitchellh/hashstructure/v2 v2.0.2 h1:vGKWl0YJqUNxE8d+h8f6NJLcCJrgbhC4NcD46KavDd4=
github.com/mitchellh/hashstructure/v2 v2.0.2/go.mod h1:MG3aRVU/N29oo/V/IhBX8GR/zz4kQkprJgF2EVszyDE=
github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY=
github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
github.com/mitchellh/mapstructure v1.3.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
github.com/mitchellh/osext v0.0.0-20151018003038-5e2d6d41470f/go.mod h1:OkQIRizQZAeMln+1tSwduZz7+Af5oFlKirV/MSYes2A=
github.com/moby/buildkit v0.8.1/go.mod h1:/kyU1hKy/aYCuP39GZA9MaKioovHku57N6cqlKZIaiQ=
github.com/moby/buildkit v0.13.0-beta3 h1:eefOGE6SsWYHFfymc09Q7VU5i3L9vUs8ZCZVCDXWNOo=
github.com/moby/buildkit v0.13.0-beta3/go.mod h1:tSWWhq1EDM0eB3ngMNDiH2hOOW9fXTyn2uXuOraCLlE=
github.com/moby/locker v1.0.1 h1:fOXqR41zeveg4fFODix+1Ch4mj/gT0NE1XJbp/epuBg=
github.com/moby/locker v1.0.1/go.mod h1:S7SDdo5zpBK84bzzVlKr2V0hz+7x9hWbYC/kq7oQppc=
github.com/moby/patternmatcher v0.6.0 h1:GmP9lR19aU5GqSSFko+5pRqHi+Ohk1O69aFiKkVGiPk=
github.com/moby/patternmatcher v0.6.0/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc=
github.com/moby/sys/mount v0.1.0/go.mod h1:FVQFLDRWwyBjDTBNQXDlWnSFREqOo3OKX9aqhmeoo74=
github.com/moby/sys/mount v0.1.1/go.mod h1:FVQFLDRWwyBjDTBNQXDlWnSFREqOo3OKX9aqhmeoo74=
github.com/moby/sys/mount v0.3.3 h1:fX1SVkXFJ47XWDoeFW4Sq7PdQJnV2QIDZAqjNqgEjUs=
github.com/moby/sys/mount v0.3.3/go.mod h1:PBaEorSNTLG5t/+4EgukEQVlAvVEc6ZjTySwKdqp5K0=
github.com/moby/sys/mountinfo v0.1.0/go.mod h1:w2t2Avltqx8vE7gX5l+QiBKxODu2TX0+Syr3h52Tw4o=
github.com/moby/sys/mountinfo v0.1.3/go.mod h1:w2t2Avltqx8vE7gX5l+QiBKxODu2TX0+Syr3h52Tw4o=
github.com/moby/sys/mountinfo v0.4.0/go.mod h1:rEr8tzG/lsIZHBtN/JjGG+LMYx9eXgW2JI+6q0qou+A=
github.com/moby/sys/mountinfo v0.6.2/go.mod h1:IJb6JQeOklcdMU9F5xQ8ZALD+CUr5VlGpwtX+VE0rpI=
github.com/moby/sys/mountinfo v0.7.1 h1:/tTvQaSJRr2FshkhXiIpux6fQ2Zvc4j7tAhMTStAG2g=
github.com/moby/sys/mountinfo v0.7.1/go.mod h1:IJb6JQeOklcdMU9F5xQ8ZALD+CUr5VlGpwtX+VE0rpI=
github.com/moby/sys/sequential v0.5.0 h1:OPvI35Lzn9K04PBbCLW0g4LcFAJgHsvXsRyewg5lXtc=
github.com/moby/sys/sequential v0.5.0/go.mod h1:tH2cOOs5V9MlPiXcQzRC+eEyab644PWKGRYaaV5ZZlo=
github.com/moby/sys/signal v0.7.0 h1:25RW3d5TnQEoKvRbEKUGay6DCQ46IxAVTT9CUMgmsSI=
github.com/moby/sys/signal v0.7.0/go.mod h1:GQ6ObYZfqacOwTtlXvcmh9A26dVRul/hbOZn88Kg8Tg=
github.com/moby/sys/user v0.1.0 h1:WmZ93f5Ux6het5iituh9x2zAG7NFY9Aqi49jjE1PaQg=
github.com/moby/sys/user v0.1.0/go.mod h1:fKJhFOnsCN6xZ5gSfbM6zaHGgDJMrqt9/reuj4T7MmU=
github.com/moby/term v0.0.0-20200915141129-7f0af18e79f2/go.mod h1:TjQg8pa4iejrUrjiz0MCtMV38jdMNW4doKSiBrEvCQQ=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v0.0.0-20180320133207-05fbef0ca5da/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
github.com/mozilla/tls-observatory v0.0.0-20190404164649-a3c1b6cfecfd/go.mod h1:SrKMQvPiws7F7iqYp8/TX+IhxCYhzr6N/1yb8cwHsGk=
github.com/mozilla/tls-observatory v0.0.0-20200317151703-4fa42e1c2dee/go.mod h1:SrKMQvPiws7F7iqYp8/TX+IhxCYhzr6N/1yb8cwHsGk=
github.com/mrunalp/fileutils v0.0.0-20200520151820-abd8a0e76976/go.mod h1:x8F1gnqOkIEiO4rqoeEEEqQbo7HjGMTvyoq3gej4iT0=
github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
github.com/muesli/termenv v0.15.2 h1:GohcuySI0QmI3wN8Ok9PtKGkgkFIk7y6Vpb5PvrY+Wo=
github.com/muesli/termenv v0.15.2/go.mod h1:Epx+iuz8sNs7mNKhxzH4fWXGNpZwUaJKRS1noLXviQ8=
github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw=
github.com/nakabonne/nestif v0.3.0/go.mod h1:dI314BppzXjJ4HsCnbo7XzrJHPszZsjnk5wEBSYHI2c=
github.com/nbutton23/zxcvbn-go v0.0.0-20180912185939-ae427f1e4c1d/go.mod h1:o96djdrsSGy3AWPyBgZMAGfxZNfgntdJG+11KU4QvbU=
github.com/ncw/swift v1.0.47/go.mod h1:23YIA4yWVnGwv2dQlN4bB7egfYX6YLn0Yo/S6zZO/ZM=
github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
github.com/onsi/ginkgo v0.0.0-20170829012221-11459a886d9c/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/ginkgo v1.8.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/ginkgo v1.10.1/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/ginkgo v1.10.3/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/ginkgo v1.11.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/ginkgo v1.12.0/go.mod h1:oUhWkIvk5aDxtKvDDuw8gItl8pKl42LzjC9KZE0HfGg=
github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
github.com/onsi/ginkgo v1.16.4 h1:29JGrr5oVBm5ulCWet69zQkzWipVXIol6ygQUe/EzNc=
github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
github.com/onsi/ginkgo/v2 v2.1.3/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c=
github.com/onsi/ginkgo/v2 v2.13.2 h1:Bi2gGVkfn6gQcjNjZJVO8Gf0FHzMPf2phUei9tejVMs=
github.com/onsi/ginkgo/v2 v2.13.2/go.mod h1:XStQ8QcGwLyF4HdfcZB8SFOS/MWCgDuXMSBe6zrvLgM=
github.com/onsi/gomega v0.0.0-20170829124025-dcabb60a477c/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
github.com/onsi/gomega v1.8.1/go.mod h1:Ho0h+IUsWyvy1OpqCwxlQ/21gkhVunqlU8fDGcoTdcA=
github.com/onsi/gomega v1.9.0/go.mod h1:Ho0h+IUsWyvy1OpqCwxlQ/21gkhVunqlU8fDGcoTdcA=
github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
github.com/onsi/gomega v1.30.0 h1:hvMK7xYz4D3HapigLTeGdId/NcfQx1VHMJc60ew99+8=
github.com/onsi/gomega v1.30.0/go.mod h1:9sxs+SwGrKI0+PWe4Fxa9tFQQBG5xSsSbMXOI8PPpoQ=
github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk=
github.com/opencontainers/go-digest v0.0.0-20170106003457-a6d0ee40d420/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s=
github.com/opencontainers/go-digest v0.0.0-20180430190053-c9281466c8b2/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s=
github.com/opencontainers/go-digest v1.0.0-rc1/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s=
github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
github.com/opencontainers/image-spec v1.0.0/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0=
github.com/opencontainers/image-spec v1.0.1/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0=
github.com/opencontainers/image-spec v1.1.0-rc5 h1:Ygwkfw9bpDvs+c9E34SdgGOj41dX/cbdlwvlWt0pnFI=
github.com/opencontainers/image-spec v1.1.0-rc5/go.mod h1:X4pATf0uXsnn3g5aiGIsVnJBR4mxhKzfwmvK/B2NTm8=
github.com/opencontainers/runc v0.0.0-20190115041553-12f6a991201f/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U=
github.com/opencontainers/runc v1.0.0-rc10/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U=
github.com/opencontainers/runc v1.0.0-rc92/go.mod h1:X1zlU4p7wOlX4+WRCz+hvlRv8phdL7UqbYD+vQwNMmE=
github.com/opencontainers/runc v1.1.12 h1:BOIssBaW1La0/qbNZHXOOa71dZfZEQOzW7dqQf3phss=
github.com/opencontainers/runc v1.1.12/go.mod h1:S+lQwSfncpBha7XTy/5lBwWgm5+y5Ma/O44Ekby9FK8=
github.com/opencontainers/runtime-spec v0.1.2-0.20190507144316-5b71a03e2700/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=
github.com/opencontainers/runtime-spec v1.0.1/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=
github.com/opencontainers/runtime-spec v1.0.2/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=
github.com/opencontainers/runtime-spec v1.0.3-0.20200728170252-4d89ac9fbff6/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=
github.com/opencontainers/runtime-spec v1.1.0 h1:HHUyrt9mwHUjtasSbXSMvs4cyFxh+Bll4AjJ9odEGpg=
github.com/opencontainers/runtime-spec v1.1.0/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=
github.com/opencontainers/runtime-tools v0.0.0-20181011054405-1d69bd0f9c39/go.mod h1:r3f7wjNzSs2extwzU3Y+6pKfobzPh+kKFJ3ofN+3nfs=
github.com/opencontainers/selinux v1.6.0/go.mod h1:VVGKuOLlE7v4PJyT6h7mNWvq1rzqiriPsEqVhc+svHE=
github.com/opencontainers/selinux v1.11.0 h1:+5Zbo97w3Lbmb3PeqQtpmTkMwsW5nRI3YaLpt7tQ7oU=
github.com/opencontainers/selinux v1.11.0/go.mod h1:E5dMC3VPuVvVHDYmi78qvhJp8+M586T4DlDRYpFkyec=
github.com/opentracing-contrib/go-grpc v0.0.0-20180928155321-4b5a12d3ff02/go.mod h1:JNdpVEzCpXBgIiv4ds+TzhN1hrtxq6ClLrTlT9OQRSc=
github.com/opentracing-contrib/go-stdlib v0.0.0-20190519235532-cf7a6c988dc9/go.mod h1:PLldrQSroqzH70Xl+1DQcGnefIbqsKR7UDaiux3zV+w=
github.com/opentracing-contrib/go-stdlib v1.0.0/go.mod h1:qtI1ogk+2JhVPIXVc6q+NHziSmy2W5GbdQZFUHADCBU=
github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc=
github.com/openzipkin/zipkin-go v0.1.1/go.mod h1:NtoC/o8u3JlF1lSlyPNswIbeQH9bJTmOf0Erfk+hxe8=
github.com/openzipkin/zipkin-go v0.1.3/go.mod h1:NtoC/o8u3JlF1lSlyPNswIbeQH9bJTmOf0Erfk+hxe8=
github.com/openzipkin/zipkin-go v0.1.6/go.mod h1:QgAqvLzwWbR/WpD4A3cGpPtJrZXNIiJc5AZX7/PBEpw=
github.com/package-url/packageurl-go v0.1.1-0.20220428063043-89078438f170 h1:DiLBVp4DAcZlBVBEtJpNWZpZVq0AEeCY7Hqk8URVs4o=
github.com/package-url/packageurl-go v0.1.1-0.20220428063043-89078438f170/go.mod h1:uQd4a7Rh3ZsVg5j0lNyAfyxIeGde9yrlhjF78GzeW0c=
github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
github.com/pelletier/go-toml v1.8.0/go.mod h1:D6yutnOGMveHEPV7VQOuvI/gXY61bv+9bAOTRnLElKs=
github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8=
github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c=
github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
github.com/phayes/checkstyle v0.0.0-20170904204023-bfd46e6a821d/go.mod h1:3OzsM7FXDQlpCiw2j81fOmAwQLnZnLGXVKUzeKQXIAw=
github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
github.com/pjbgf/sha1cd v0.3.0 h1:4D5XXmUUBUl/xQ6IjCkEAbqXskkq/4O7LmGn0AqMDs4=
github.com/pjbgf/sha1cd v0.3.0/go.mod h1:nZ1rrWOcGJ5uZgEEVL1VUM9iRQiZvWdbZjkKyFzPPsI=
github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8 h1:KoWmjvw+nsYOo29YJK9vDA65RGE3NrOnUtO7a+RF9HU=
github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8/go.mod h1:HKlIX3XHQyzLZPlr7++PzdhaXEj94dEiJgZDTsxEqUI=
github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.8.1-0.20171018195549-f15c970de5b7/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/profile v1.5.0 h1:042Buzk+NhDI+DeSAA62RwJL8VAuZUMQZUjCsRz1Mug=
github.com/pkg/profile v1.5.0/go.mod h1:qBsxPvzyUincmltOk6iyRVxHYg4adc0OFOv72ZdLa18=
github.com/pmezard/go-difflib v0.0.0-20151028094244-d8ed2627bdf0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
github.com/pquerna/cachecontrol v0.0.0-20171018203845-0dec1b30a021/go.mod h1:prYjPmNq4d1NPVmpShWobRqXY3q7Vp+80DqgxxUrUIA=
github.com/prometheus/client_golang v0.0.0-20180209125602-c332b6f63c06/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
github.com/prometheus/client_golang v0.8.0/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs=
github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
github.com/prometheus/client_golang v1.1.0/go.mod h1:I1FGZT9+L76gKKOs5djB6ezCbFQP1xR9D75/vuwEF3g=
github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
github.com/prometheus/client_golang v1.12.1/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
github.com/prometheus/client_golang v1.13.0/go.mod h1:vTeo+zgvILHsnnj/39Ou/1fPN5nJFOEMgftOUOmlvYQ=
github.com/prometheus/client_golang v1.17.0 h1:rl2sfwZMtSthVU752MqfjQozy7blglC+1SOtjMAMh+Q=
github.com/prometheus/client_golang v1.17.0/go.mod h1:VeL+gMmOAxkS2IqfCq0ZmHSL+LjWfWDUmp1mBz9JgUY=
github.com/prometheus/client_model v0.0.0-20171117100541-99fa1f4be8e5/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/prometheus/client_model v0.4.1-0.20230718164431-9a2bf3000d16 h1:v7DLqVdK4VrYkVD5diGdl4sxJurKJEMnODWRJlxV9oM=
github.com/prometheus/client_model v0.4.1-0.20230718164431-9a2bf3000d16/go.mod h1:oMQmHW1/JoDwqLtg57MGgP/Fb1CJEYF2imWWhWtMkYU=
github.com/prometheus/common v0.0.0-20180110214958-89604d197083/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
github.com/prometheus/common v0.0.0-20180801064454-c7de2306084e/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc=
github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
github.com/prometheus/common v0.37.0/go.mod h1:phzohg0JFMnBEFGxTDbfu3QyL5GI8gTQJFhYO5B3mfA=
github.com/prometheus/common v0.44.0 h1:+5BrQJwiBB9xsMygAB3TNvpQKOwlkc25LbISbrdOOfY=
github.com/prometheus/common v0.44.0/go.mod h1:ofAIvZbQ1e/nugmZGz4/qCb9Ap1VoSTIO7x0VV9VvuY=
github.com/prometheus/exporter-toolkit v0.8.2/go.mod h1:00shzmJL7KxcsabLWcONwpyNEuWhREOnFqZW7vadFS0=
github.com/prometheus/procfs v0.0.0-20180125133057-cb4147076ac7/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
github.com/prometheus/procfs v0.0.0-20180725123919-05ee40e3a273/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
github.com/prometheus/procfs v0.0.0-20190522114515-bc1a522cf7b1/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
github.com/prometheus/procfs v0.0.3/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDaekg4FpcdQ=
github.com/prometheus/procfs v0.0.5/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDaekg4FpcdQ=
github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
github.com/prometheus/procfs v0.8.0/go.mod h1:z7EfXMXOkbkqb9IINtpCn86r/to3BnA0uaxHdg830/4=
github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo=
github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo=
github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
github.com/psanford/memfs v0.0.0-20230130182539-4dbf7e3e865e h1:51xcRlSMBU5rhM9KahnJGfEsBPVPz3182TgFRowA8yY=
github.com/psanford/memfs v0.0.0-20230130182539-4dbf7e3e865e/go.mod h1:tcaRap0jS3eifrEEllL6ZMd9dg8IlDpi2S1oARrQ+NI=
github.com/quasilyte/go-consistent v0.0.0-20190521200055-c6f3937de18c/go.mod h1:5STLWrekHfjyYwxBRVRXNOSewLJ3PWfDJd1VyTS21fI=
github.com/quasilyte/go-ruleguard v0.1.2-0.20200318202121-b00d7a75d3d8/go.mod h1:CGFX09Ci3pq9QZdj86B+VGIdNj4VyCo2iPOGS9esB/k=
github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
github.com/remyoudompheng/bigfft v0.0.0-20170806203942-52369c62f446/go.mod h1:uYEyJGbgTkfkS4+E/PavXkNJcbFIpEtjt2B0KDQ5+9M=
github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
github.com/rivo/uniseg v0.4.6 h1:Sovz9sDSwbOz9tgUy8JpT+KgCkPYJEN/oYzlJiYTNLg=
github.com/rivo/uniseg v0.4.6/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
github.com/rogpeppe/fastuuid v1.1.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
github.com/rogpeppe/go-internal v1.5.2/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
github.com/rs/cors v1.10.0 h1:62NOS1h+r8p1mW6FM0FSB0exioXLhd/sh15KpjWBZ+8=
github.com/rs/cors v1.10.0/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU=
github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
github.com/rs/zerolog v1.32.0 h1:keLypqrlIjaFsbmJOBdB/qvyF8KEtCWHwobLp5l/mQ0=
github.com/rs/zerolog v1.32.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
github.com/rubiojr/go-vhd v0.0.0-20160810183302-0bfd3b39853c/go.mod h1:DM5xW0nvfNNm2uytzsvhI3OnX8uzaRAg8UX/CnDqbto=
github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/ryancurrah/gomodguard v1.0.4/go.mod h1:9T/Cfuxs5StfsocWr4WzDL36HqnX0fVb9d5fSEaLhoE=
github.com/ryancurrah/gomodguard v1.1.0/go.mod h1:4O8tr7hBODaGE6VIhfJDHcwzh5GUccKSJBU0UMXJFVM=
github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
github.com/samber/lo v1.38.1 h1:j2XEAqXKb09Am4ebOg31SpvzUTTs6EN3VfgeLUhPdXM=
github.com/samber/lo v1.38.1/go.mod h1:+m/ZKRl6ClXCE2Lgf3MsQlWfh4bn1bz6CXEOxnEXnEA=
github.com/samber/slog-common v0.14.0 h1:g4TGALXmqogbJu3epRhjIWUJKSpgqB9VyN2OEnS8Wyg=
github.com/samber/slog-common v0.14.0/go.mod h1:Qjrfhwk79XiCIhBj8+jTq1Cr0u9rlWbjawh3dWXzaHk=
github.com/samber/slog-logrus/v2 v2.2.0 h1:Noku55MKf/x57c2j5/LsLzw75biW86Q29bOkZpnLAgY=
github.com/samber/slog-logrus/v2 v2.2.0/go.mod h1:C0egl62QrwHPY9RcsEXa3E7FHb6/xM9uaVSuc7piJXU=
github.com/sassoftware/go-rpmutils v0.0.0-20190420191620-a8f1baeba37b/go.mod h1:am+Fp8Bt506lA3Rk3QCmSqmYmLMnPDhdDUcosQCAx+I=
github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
github.com/sclevine/spec v1.2.0/go.mod h1:W4J29eT/Kzv7/b9IWLB055Z+qvVC9vt0Arko24q7p+U=
github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
github.com/sebdah/goldie/v2 v2.5.3 h1:9ES/mNN+HNUbNWpVAlrzuZ7jE+Nrczbj8uFRjM7624Y=
github.com/sebdah/goldie/v2 v2.5.3/go.mod h1:oZ9fp0+se1eapSRjfYbsV/0Hqhbuu3bJVvKI/NNtssI=
github.com/seccomp/libseccomp-golang v0.9.1/go.mod h1:GbW5+tmTXfcxTToHLXlScSlAvWlF4P2Ca7zGrPiEpWo=
github.com/secure-systems-lab/go-securesystemslib v0.4.0 h1:b23VGrQhTA8cN2CbBw7/FulN9fTtqYUdS5+Oxzt+DUE=
github.com/secure-systems-lab/go-securesystemslib v0.4.0/go.mod h1:FGBZgq2tXWICsxWQW1msNf49F0Pf2Op5Htayx335Qbs=
github.com/securego/gosec v0.0.0-20200103095621-79fbf3af8d83/go.mod h1:vvbZ2Ae7AzSq3/kywjUDxSNq2SJ27RxCz2un0H3ePqE=
github.com/securego/gosec v0.0.0-20200401082031-e946c8c39989/go.mod h1:i9l/TNj+yDFh9SZXUTvspXTjbFXgZGP/UvhU1S65A4A=
github.com/securego/gosec/v2 v2.3.0/go.mod h1:UzeVyUXbxukhLeHKV3VVqo7HdoQR9MrRfFmZYotn8ME=
github.com/sercand/kuberesolver v2.4.0+incompatible/go.mod h1:lWF3GL0xptCB/vCiJPl/ZshwPsX/n4Y7u0CW9E7aQIQ=
github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
github.com/serialx/hashring v0.0.0-20190422032157-8b2912629002/go.mod h1:/yeG0My1xr/u+HZrFQ1tOQQQQrOawfyMUH13ai5brBc=
github.com/shibumi/go-pathspec v1.3.0 h1:QUyMZhFo0Md5B8zV8x2tesohbb5kfbpTi9rBnKh5dkI=
github.com/shibumi/go-pathspec v1.3.0/go.mod h1:Xutfslp817l2I1cZvgcfeMQJG5QnU2lh5tVaaMCl3jE=
github.com/shirou/gopsutil v0.0.0-20190901111213-e4ec7b275ada/go.mod h1:WWnYX4lzhCH5h/3YBfyVA3VbLYjlMZZAQcW9ojMexNc=
github.com/shirou/w32 v0.0.0-20160930032740-bb4de0191aa4/go.mod h1:qsXQc7+bwAM3Q1u/4XEfrquwF8Lw7D7y5cD8CuHnfIc=
github.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e/go.mod h1:TDJrrUr11Vxrven61rcy3hJMUqaf/CLWYhHNPmT14Lk=
github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041/go.mod h1:N5mDOmsrJOB+vfqUK+7DmDyjhSLIIBnXo9lvZJj3MWQ=
github.com/shurcooL/graphql v0.0.0-20220606043923-3cf50f8a0a29 h1:B1PEwpArrNp4dkQrfxh/abbBAOZBVp0ds+fBEOUOqOc=
github.com/shurcooL/graphql v0.0.0-20220606043923-3cf50f8a0a29/go.mod h1:AuYgA5Kyo4c7HfUmvRGs/6rGlMMV/6B1bVnB9JxJEEg=
github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
github.com/sirupsen/logrus v1.0.4-0.20170822132746-89742aefa4b2/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc=
github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
github.com/skeema/knownhosts v1.2.1 h1:SHWdIUa82uGZz+F+47k8SY4QhhI291cXCpopT1lK2AQ=
github.com/skeema/knownhosts v1.2.1/go.mod h1:xYbVRSPxqBZFrdmDyMmsOs+uX1UZC3nTN3ThzgDxUwo=
github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
github.com/smartystreets/assertions v1.0.0/go.mod h1:kHHU4qYBaI3q23Pp3VPrmWhuIUrLW/7eUrw0BU5VaoM=
github.com/smartystreets/go-aws-auth v0.0.0-20180515143844-0c1422d1fdb9/go.mod h1:SnhjPscd9TpLiy1LpzGSKh3bXCfxxXuqd9xmQJy3slM=
github.com/smartystreets/goconvey v0.0.0-20190330032615-68dc04aab96a/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
github.com/smartystreets/gunit v1.0.0/go.mod h1:qwPWnhz6pn0NnRBP++URONOVyNkPyr4SauJk4cUOwJs=
github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
github.com/sosodev/duration v1.1.0 h1:kQcaiGbJaIsRqgQy7VGlZrVw1giWO+lDoX3MCPnpVO4=
github.com/sosodev/duration v1.1.0/go.mod h1:RQIBBX0+fMLc/D9+Jb/fwvVmo0eZvDDEERAikUR6SDg=
github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
github.com/sourcegraph/go-diff v0.5.1/go.mod h1:j2dHj3m8aZgQO8lMTcTnBcXkRRRqi34cd2MNlA9u1mE=
github.com/sourcegraph/go-diff v0.5.3/go.mod h1:v9JDtjCE4HHHCZGId75rg8gkKKa98RVjBcBGsVmMmak=
github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
github.com/spdx/gordf v0.0.0-20201111095634-7098f93598fb/go.mod h1:uKWaldnbMnjsSAXRurWqqrdyZen1R7kxl8TkmWk2OyM=
github.com/spdx/tools-golang v0.5.1 h1:fJg3SVOGG+eIva9ZUBm/hvyA7PIPVFjRxUKe6fdAgwE=
github.com/spdx/tools-golang v0.5.1/go.mod h1:/DRDQuBfB37HctM29YtrX1v+bXiVmT2OpQDalRmX9aU=
github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
github.com/spf13/cobra v0.0.2-0.20171109065643-2da4a54c5cee/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE=
github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo=
github.com/spf13/pflag v0.0.0-20170130214245-9ff6c6923cff/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
github.com/spf13/pflag v1.0.1-0.20171106142849-4c012f6dcd95/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
github.com/spf13/viper v1.6.1/go.mod h1:t3iDnF5Jlj76alVNuyFBk5oUMCvsrkbvZK0WQdfDi5k=
github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg=
github.com/stretchr/objx v0.0.0-20180129172003-8a3f7159479f/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
github.com/stretchr/testify v0.0.0-20151208002404-e3a8ff8ce365/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v0.0.0-20180303142811-b89eecf5ca5d/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
github.com/syndtr/gocapability v0.0.0-20170704070218-db04d3cc01c8/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww=
github.com/syndtr/gocapability v0.0.0-20180916011248-d98352740cb2/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww=
github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA=
github.com/tdakkota/asciicheck v0.0.0-20200416190851-d7f85be797a2/go.mod h1:yHp0ai0Z9gUljN3o0xMhYJnH/IcvkdTBOX2fmJ93JEM=
github.com/tdakkota/asciicheck v0.0.0-20200416200610-e657995f937b/go.mod h1:yHp0ai0Z9gUljN3o0xMhYJnH/IcvkdTBOX2fmJ93JEM=
github.com/tetafro/godot v0.3.7/go.mod h1:/7NLHhv08H1+8DNj0MElpAACw1ajsCuf3TKNQxA5S+0=
github.com/tetafro/godot v0.4.2/go.mod h1:/7NLHhv08H1+8DNj0MElpAACw1ajsCuf3TKNQxA5S+0=
github.com/tidwall/gjson v1.17.0 h1:/Jocvlh98kcTfpN2+JzGQWQcqrPQwDrVEMApx/M5ZwM=
github.com/tidwall/gjson v1.17.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
github.com/tidwall/pretty v1.2.0/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
github.com/timakin/bodyclose v0.0.0-20190930140734-f7f2e9bca95e/go.mod h1:Qimiffbc6q9tBWlVV6x0P9sat/ao1xEkREYPPj9hphk=
github.com/timakin/bodyclose v0.0.0-20200424151742-cb6215831a94/go.mod h1:Qimiffbc6q9tBWlVV6x0P9sat/ao1xEkREYPPj9hphk=
github.com/tj/assert v0.0.0-20171129193455-018094318fb0/go.mod h1:mZ9/Rh9oLWpLLDRpvE+3b7gP/C2YyLFYxNmcLnPTMe0=
github.com/tj/go-elastic v0.0.0-20171221160941-36157cbbebc2/go.mod h1:WjeM0Oo1eNAjXGDx2yma7uG2XoyRZTq1uv3M/o7imD0=
github.com/tj/go-kinesis v0.0.0-20171128231115-08b17f58cb1b/go.mod h1:/yhzCV0xPfx6jb1bBgRFjl5lytqVqZXEaeqWP8lTEao=
github.com/tj/go-spin v1.1.0/go.mod h1:Mg1mzmePZm4dva8Qz60H2lHwmJ2loum4VIrLgVnKwh4=
github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
github.com/tommy-muehle/go-mnd v1.1.1/go.mod h1:dSUh0FtTP8VhvkL1S+gUR1OKd9ZnSaozuI6r3m6wOig=
github.com/tommy-muehle/go-mnd v1.3.1-0.20200224220436-e6f9a994e8fa/go.mod h1:dSUh0FtTP8VhvkL1S+gUR1OKd9ZnSaozuI6r3m6wOig=
github.com/tonistiigi/fsutil v0.0.0-20201103201449-0834f99b7b85/go.mod h1:a7cilN64dG941IOXfhJhlH0qB92hxJ9A1ewrdUmJ6xo=
github.com/tonistiigi/fsutil v0.0.0-20230825212630-f09800878302 h1:ZT8ibgassurSISJ1Pj26NsM3vY2jxFZn63Nd/TpHmRw=
github.com/tonistiigi/fsutil v0.0.0-20230825212630-f09800878302/go.mod h1:9kMVqMyQ/Sx2df5LtnGG+nbrmiZzCS7V6gjW3oGHsvI=
github.com/tonistiigi/go-actions-cache v0.0.0-20220404170428-0bdeb6e1eac7 h1:8eY6m1mjgyB8XySUR7WvebTM8D/Vs86jLJzD/Tw7zkc=
github.com/tonistiigi/go-actions-cache v0.0.0-20220404170428-0bdeb6e1eac7/go.mod h1:qqvyZqkfwkoJuPU/bw61bItaoO0SJ8YSW0vSVRRvsRg=
github.com/tonistiigi/go-archvariant v1.0.0 h1:5LC1eDWiBNflnTF1prCiX09yfNHIxDC/aukdhCdTyb0=
github.com/tonistiigi/go-archvariant v1.0.0/go.mod h1:TxFmO5VS6vMq2kvs3ht04iPXtu2rUT/erOnGFYfk5Ho=
github.com/tonistiigi/units v0.0.0-20180711220420-6950e57a87ea h1:SXhTLE6pb6eld/v/cCndK0AMpt1wiVFb/YYmqB3/QG0=
github.com/tonistiigi/units v0.0.0-20180711220420-6950e57a87ea/go.mod h1:WPnis/6cRcDZSUvVmezrxJPkiO87ThFYsoUiMwWNDJk=
github.com/tonistiigi/vt100 v0.0.0-20230623042737-f9a4f7ef6531 h1:Y/M5lygoNPKwVNLMPXgVfsRT40CSFKXCxuU8LoHySjs=
github.com/tonistiigi/vt100 v0.0.0-20230623042737-f9a4f7ef6531/go.mod h1:ulncasL3N9uLrVann0m+CDlJKWsIAP34MPcOJF6VRvc=
github.com/uber/jaeger-client-go v2.25.0+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk=
github.com/uber/jaeger-client-go v2.28.0+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk=
github.com/uber/jaeger-lib v2.2.0+incompatible/go.mod h1:ComeNDZlWwrWnDv8aPp0Ba6+uUTzImX/AauajbLI56U=
github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
github.com/ulikunitz/xz v0.5.6/go.mod h1:2bypXElzHzzJZwzH67Y6wb67pO62Rzfn7BSiF4ABRW8=
github.com/ulikunitz/xz v0.5.7/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
github.com/ultraware/funlen v0.0.2/go.mod h1:Dp4UiAus7Wdb9KUZsYWZEWiRzGuM2kXM1lPbfaF6xhA=
github.com/ultraware/whitespace v0.0.4/go.mod h1:aVMh/gQve5Maj9hQ/hg+F75lr/X5A89uZnzAmWSineA=
github.com/urfave/cli v0.0.0-20171014202726-7bc6a0acffa5/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
github.com/urfave/cli v1.22.2/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
github.com/urfave/cli v1.22.14 h1:ebbhrRiGK2i4naQJr+1Xj92HXZCrK7MsyTS/ob3HnAk=
github.com/urfave/cli v1.22.14/go.mod h1:X0eDS6pD6Exaclxm99NJ3FiCDRED7vIHpx2mDOHLvkA=
github.com/uudashr/gocognit v1.0.1/go.mod h1:j44Ayx2KW4+oB6SWMv8KsmHzZrOInQav7D3cQMJ5JUM=
github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
github.com/valyala/fasthttp v1.2.0/go.mod h1:4vX61m6KN+xDduDNwXrhIAVZaZaZiQ1luJk8LWSxF3s=
github.com/valyala/quicktemplate v1.2.0/go.mod h1:EH+4AkTd43SvgIbQHYu59/cJyxDoOVRUAfrukLPuGJ4=
github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio=
github.com/vbatts/tar-split v0.11.5 h1:3bHCTIheBm1qFTcgh9oPu+nNBtX+XJIupG/vacinCts=
github.com/vbatts/tar-split v0.11.5/go.mod h1:yZbwRsSeGjusneWgA781EKej9HF8vme8okylkAeNKLk=
github.com/vdemeester/k8s-pkg-credentialprovider v1.17.4/go.mod h1:inCTmtUdr5KJbreVojo06krnTgaeAz/Z7lynpPk/Q2c=
github.com/vektah/gqlparser/v2 v2.5.10 h1:6zSM4azXC9u4Nxy5YmdmGu4uKamfwsdKTwp5zsEealU=
github.com/vektah/gqlparser/v2 v2.5.10/go.mod h1:1rCcfwB2ekJofmluGWXMSEnPMZgbxzwj6FaZ/4OT8Cc=
github.com/vishvananda/netlink v1.1.0/go.mod h1:cTgwzPIzzgDAYoQrMm0EdrjRUBkTqKYppBueQtXaqoE=
github.com/vishvananda/netlink v1.2.1-beta.2 h1:Llsql0lnQEbHj0I1OuKyp8otXp0r3q0mPkuhwHfStVs=
github.com/vishvananda/netlink v1.2.1-beta.2/go.mod h1:twkDnbuQxJYemMlGd4JFIcuhgX83tXhKS2B/PRMpOho=
github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df/go.mod h1:JP3t17pCcGlemwknint6hfoeCVQrEMVwxRLRjXpq+BU=
github.com/vishvananda/netns v0.0.0-20200728191858-db3c7e526aae/go.mod h1:DD4vA1DwXk04H54A1oHXtwZmA0grkVMdPxx/VGLCah0=
github.com/vishvananda/netns v0.0.4 h1:Oeaw1EM2JMxD51g9uhtC0D7erkIjgmj8+JZc26m1YX8=
github.com/vishvananda/netns v0.0.4/go.mod h1:SpkAiCQRtJ6TvvxPnOSyH3BMl6unz3xZlaprSwhNNJM=
github.com/vito/midterm v0.1.5-0.20240215023001-e649b2677bfa h1:2zKtb3ChJT0FBEt+AU64Rk3hT2kPjNf94QEyyDYaBaE=
github.com/vito/midterm v0.1.5-0.20240215023001-e649b2677bfa/go.mod h1:2ujYuyOObdWrQtnXAzwSBcPRKhC5Q96ex0nsf2Dmfzk=
github.com/vito/progrock v0.10.2-0.20240221152222-63c8df30db8d h1:hh9zh0tcr3/th/mtxEpzLVE8rvx+LejDrbWmqmi+RUM=
github.com/vito/progrock v0.10.2-0.20240221152222-63c8df30db8d/go.mod h1:Q8hxIUXZW8vkezLwH4TnRmXv+XdRb4KfLtS9t5RtH9g=
github.com/vmware/govmomi v0.20.3/go.mod h1:URlwyTFZX72RmxtxuaFL2Uj3fD1JTvZdx59bHWk6aFU=
github.com/weaveworks/common v0.0.0-20230119144549-0aaa5abd1e63 h1:qZcnPZbiX8gGs3VmipVc3ft29vPYBZzlox/04Von6+k=
github.com/weaveworks/common v0.0.0-20230119144549-0aaa5abd1e63/go.mod h1:KoQ+3z63GUJzQ7AhU0AWQNU+LPda2EwL/cx1PlbDzVQ=
github.com/weaveworks/promrus v1.2.0 h1:jOLf6pe6/vss4qGHjXmGz4oDJQA+AOCqEL3FvvZGz7M=
github.com/weaveworks/promrus v1.2.0/go.mod h1:SaE82+OJ91yqjrE1rsvBWVzNZKcHYFtMUyS1+Ogs/KA=
github.com/willf/bitset v1.1.11-0.20200630133818-d5bec3311243/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4=
github.com/xanzy/go-gitlab v0.31.0/go.mod h1:sPLojNBn68fMUWSxIJtdVVIP8uSBYqesTfDUseX11Ug=
github.com/xanzy/go-gitlab v0.32.0/go.mod h1:sPLojNBn68fMUWSxIJtdVVIP8uSBYqesTfDUseX11Ug=
github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw=
github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
github.com/xeipuuv/gojsonschema v0.0.0-20180618132009-1d523034197f/go.mod h1:5yf86TLmAcydyeJq5YvxkGPE2fm/u4myDekKRoLuqhs=
github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8/go.mod h1:HUYIGzjTL3rfEspMxjDjgmT5uz5wzYJKVo23qUhYTos=
github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
github.com/yuin/goldmark v1.6.0 h1:boZcn2GTjpsynOsC0iJHnBWa4Bi0qzfJjthwauItG68=
github.com/yuin/goldmark v1.6.0/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
github.com/yvasiyarov/go-metrics v0.0.0-20140926110328-57bccd1ccd43/go.mod h1:aX5oPXxHm3bOH+xeAttToC8pqch2ScQN/JoXYupl6xs=
github.com/yvasiyarov/gorelic v0.0.0-20141212073537-a9bba5b9ab50/go.mod h1:NUSPSUX/bi6SeDMUh6brw0nXpxHnc96TguQh0+r/ssA=
github.com/yvasiyarov/newrelic_platform_go v0.0.0-20140908184405-b21fdbd4370f/go.mod h1:GlGEuHIJweS1mbCqG+7vt2nvWLzLLnRHbXz5JKd/Qbg=
github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
github.com/zmb3/spotify/v2 v2.3.1 h1:aEyIPotROM3JJjHMCImFROgnPIUpzVo8wymYSaPSd9w=
github.com/zmb3/spotify/v2 v2.3.1/go.mod h1:+LVh9CafHu7SedyqYmEf12Rd01dIVlEL845yNhksW0E=
go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
go.etcd.io/bbolt v1.3.5/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ=
go.etcd.io/bbolt v1.3.7 h1:j+zJOnnEjF/kyHlDDgGnVL/AIqIJPq8UoB2GSNfkUfQ=
go.etcd.io/bbolt v1.3.7/go.mod h1:N9Mkw9X8x5fupy0IKsmuqVtoGDyxsaDlbk4Rd05IAQw=
go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg=
go.opencensus.io v0.15.0/go.mod h1:UffZAU+4sDEINUGP/B7UfBBkq4fqLu9zXAX7ke6CHW0=
go.opencensus.io v0.18.0/go.mod h1:vKdFvxhtzZ9onBp9VKHK8z/sRpBMnKAsufL7wlDrCOA=
go.opencensus.io v0.19.1/go.mod h1:gug0GbSHa8Pafr0d2urOSgoXHZ6x/RUlaiT0d9pqb4A=
go.opencensus.io v0.19.2/go.mod h1:NO/8qkisMZLZ1FCsKNqtJPwc8/TaclWyY0B6wcYNg9M=
go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0=
go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo=
go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.46.0 h1:PzIubN4/sjByhDRHLviCjJuweBXWFZWhghjg7cS28+M=
go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.46.0/go.mod h1:Ct6zzQEuGK3WpJs2n4dn+wfJYzd/+hNnxMRTWjGn30M=
go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.45.0 h1:2ea0IkZBsWH+HA2GkD+7+hRw2u97jzdFyRtXuO14a1s=
go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.45.0/go.mod h1:4m3RnBBb+7dB9d21y510oO1pdB1V4J6smNf14WXcBFQ=
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.45.0 h1:x8Z78aZx8cOF0+Kkazoc7lwUNMGy0LrzEMxTm4BbTxg=
go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.45.0/go.mod h1:62CPTSry9QZtOaSsE3tOzhx6LzDhHnXJ6xHeMNNiM6Q=
go.opentelemetry.io/otel v1.21.0 h1:hzLeKBZEL7Okw2mGzZ0cc4k/A7Fta0uoPgaJCr8fsFc=
go.opentelemetry.io/otel v1.21.0/go.mod h1:QZzNPQPm1zLX4gZK4cMi+71eaorMSGT3A4znnUvNNEo=
go.opentelemetry.io/otel/exporters/jaeger v1.17.0 h1:D7UpUy2Xc2wsi1Ras6V40q806WM07rqoCWzXu7Sqy+4=
go.opentelemetry.io/otel/exporters/jaeger v1.17.0/go.mod h1:nPCqOnEH9rNLKqH/+rrUjiMzHJdV1BlpKcTwRTyKkKI=
go.opentelemetry.io/otel/exporters/otlp/otlpmetric v0.42.0 h1:ZtfnDL+tUrs1F0Pzfwbg2d59Gru9NCH3bgSHBM6LDwU=
go.opentelemetry.io/otel/exporters/otlp/otlpmetric v0.42.0/go.mod h1:hG4Fj/y8TR/tlEDREo8tWstl9fO9gcFkn4xrx0Io8xU=
go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v0.42.0 h1:NmnYCiR0qNufkldjVvyQfZTHSdzeHoZ41zggMsdMcLM=
go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v0.42.0/go.mod h1:UVAO61+umUsHLtYb8KXXRoHtxUkdOPkYidzW3gipRLQ=
go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v0.42.0 h1:wNMDy/LVGLj2h3p6zg4d0gypKfWKSWI14E1C4smOgl8=
go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp v0.42.0/go.mod h1:YfbDdXAAkemWJK3H/DshvlrxqFB2rtW4rY6ky/3x/H0=
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0 h1:cl5P5/GIfFh4t6xyruOgJP5QiA1pw4fYYdv6nc6CBWw=
go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0/go.mod h1:zgBdWWAu7oEEMC06MMKc5NLbA/1YDXV1sMpSqEeLQLg=
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.21.0 h1:tIqheXEFWAZ7O8A7m+J0aPTmpJN3YQ7qetUAdkkkKpk=
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.21.0/go.mod h1:nUeKExfxAQVbiVFn32YXpXZZHZ61Cc3s3Rn1pDBGAb0=
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.19.0 h1:IeMeyr1aBvBiPVYihXIaeIZba6b8E1bYp7lbdxK8CQg=
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.19.0/go.mod h1:oVdCUtjq9MK9BlS7TtucsQwUcXcymNiEDjgDD2jMtZU=
go.opentelemetry.io/otel/exporters/prometheus v0.42.0 h1:jwV9iQdvp38fxXi8ZC+lNpxjK16MRcZlpDYvbuO1FiA=
go.opentelemetry.io/otel/exporters/prometheus v0.42.0/go.mod h1:f3bYiqNqhoPxkvI2LrXqQVC546K7BuRDL/kKuxkujhA=
go.opentelemetry.io/otel/metric v1.21.0 h1:tlYWfeo+Bocx5kLEloTjbcDwBuELRrIFxwdQ36PlJu4=
go.opentelemetry.io/otel/metric v1.21.0/go.mod h1:o1p3CA8nNHW8j5yuQLdc1eeqEaPfzug24uvsyIEJRWM=
go.opentelemetry.io/otel/sdk v1.21.0 h1:FTt8qirL1EysG6sTQRZ5TokkU8d0ugCj8htOgThZXQ8=
go.opentelemetry.io/otel/sdk v1.21.0/go.mod h1:Nna6Yv7PWTdgJHVRD9hIYywQBRx7pbox6nwBnZIxl/E=
go.opentelemetry.io/otel/sdk/metric v1.19.0 h1:EJoTO5qysMsYCa+w4UghwFV/ptQgqSL/8Ni+hx+8i1k=
go.opentelemetry.io/otel/sdk/metric v1.19.0/go.mod h1:XjG0jQyFJrv2PbMvwND7LwCEhsJzCzV5210euduKcKY=
go.opentelemetry.io/otel/trace v1.21.0 h1:WD9i5gzvoUPuXIXH24ZNBudiarZDKuekPqi/E8fpfLc=
go.opentelemetry.io/otel/trace v1.21.0/go.mod h1:LGbsEB0f9LGjN+OZaQQ26sohbOmiMR+BaslueVtS/qQ=
go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
go.opentelemetry.io/proto/otlp v1.0.0 h1:T0TX0tmXU8a3CbNXzEKGeU5mIVOdf0oykP+u2lIVU/I=
go.opentelemetry.io/proto/otlp v1.0.0/go.mod h1:Sy6pihPLfYHkr3NkUbEhGHFhINUSI/v80hjKIs5JXpM=
go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
go.uber.org/atomic v1.5.1/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4=
go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE=
gocloud.dev v0.19.0/go.mod h1:SmKwiR8YwIMMJvQBKLsC3fHNyMwXLw3PMDO+VVteJMI=
golang.org/x/build v0.0.0-20190314133821-5284462c4bec/go.mod h1:atTaCNAy0f16Ah5aV1gMSwgiKVHwu/JncqDpuRr7lS4=
golang.org/x/crypto v0.0.0-20171113213409-9f005a07e0d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20181030102418-4d3f4d9ffa16/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20191002192127-34f69633bfdc/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/crypto v0.0.0-20201117144127-c1f2f97bffc9/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
golang.org/x/crypto v0.0.0-20221012134737-56aed061732a/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
golang.org/x/crypto v0.3.1-0.20221117191849-2c476679df9a/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4=
golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU=
golang.org/x/crypto v0.20.0 h1:jmAMJJZXr5KiCw05dfYK9QnqaqKLYXijU23lsEdcQqg=
golang.org/x/crypto v0.20.0/go.mod h1:Xwo95rrVNIoSMx9wa1JroENMToLWn3RNVrTBpLHgZPQ=
golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20190312203227-4b39c73a6495/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ=
golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE=
golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
golang.org/x/image v0.14.0 h1:tNgSxAFe3jC4uYqvZdTr84SZoM1KfwdC9SKIFrLjFn4=
golang.org/x/image v0.14.0/go.mod h1:HUYqC05R2ZcZ3ejNQsIHQDQiwWM4JBqmm6MKANTp4LE=
golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/lint v0.0.0-20181217174547-8f45f776aaf1/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0=
golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
golang.org/x/net v0.0.0-20170114055629-f2499483f923/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180911220305-26e67e76b6c3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181029044818-c44066c5c816/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181106065722-10aee1819953/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181108082009-03003ca0c849/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190619014844-b5b0513f8c1b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20191004110552-13f9640d40b9/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20191112182307-2180aed22343/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc=
golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk=
golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20210916014120-12bc252f5db8/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220412020605-290c469a71a5/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY=
golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc=
golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
golang.org/x/oauth2 v0.0.0-20180724155351-3d292e4d0cdc/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.0.0-20181106182150-f42d05182288/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/oauth2 v0.0.0-20190402181905-9f3314589c9a/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210810183815-faf39c7919d5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
golang.org/x/oauth2 v0.0.0-20220309155454-6242fa91716a/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc=
golang.org/x/oauth2 v0.0.0-20220608161450-d0670ef3b1eb/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE=
golang.org/x/oauth2 v0.0.0-20220909003341-f21342109be1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg=
golang.org/x/oauth2 v0.17.0 h1:6m3ZPmLEFdVxKKWnKq4VqZ60gutO35zm+zrAHVmHyDQ=
golang.org/x/oauth2 v0.17.0/go.mod h1:OzPDGQiuQMguemayvdylqddI7qcD9lnSDb+1FiwQ5HA=
golang.org/x/perf v0.0.0-20180704124530-6e6d33e29852/go.mod h1:JLpeXjPJfIyPr5TlbXLkXWLhP8nz10XfvxElABhCtcw=
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sys v0.0.0-20170830134202-bb24a47a89ea/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181029174526-d69651ed3497/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181218192612-074acd46bca6/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190209173611-3b5209105503/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190514135907-3a4b5fb9f71f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190602015325-4c4f7f33c9ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190606203320-7fc4e5ec1444/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190616124812-15dcb6c0061f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190620070143-6f217b454f45/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190801041406-cbf593c0f2f3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190922100055-0a153f010e69/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191022100944-742c48ecaeb7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191112214154-59a1497f0cea/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191115151921-52ab43148777/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191210023423-ac6580df4449/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200120151820-655fe14d7479/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200124204421-9fbb57f87de9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200217220822-9197077df867/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200728102440-3e129f6d46b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200831180312-196b9ba8737a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200916030750-2334cc1a136f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200917073148-efd3b9a0ff20/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201013081832-0aaa2718063a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210616045830-e2b7044e8c71/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20211025201205-69cdffdb9359/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220328115105-d36c6a25d886/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220502124256-b6088ccd6cba/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc=
golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
golang.org/x/term v0.17.0 h1:mkTF7LCd6WGJNL3K1Ad7kwxNfYAW6a8a8QqtMblp/4U=
golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
golang.org/x/text v0.0.0-20160726164857-2910a502d2bf/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.0.0-20200416051211-89c76fbcd5d1/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20181011042414-1f849cf54d09/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20181117154741-2ddaf7f79a09/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20181219222714-6e267b5cc78e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190110163146-51295c7ec13a/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190206041539-40960b6deb8e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190221204921-83362c3779f5/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190311215038-5c2858a9cfe5/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190322203728-c1a832b0ad89/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190422233926-fe54fb35175b/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
golang.org/x/tools v0.0.0-20190521203540-521d6ed310dd/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
golang.org/x/tools v0.0.0-20190614205625-5aca471b1d59/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
golang.org/x/tools v0.0.0-20190624222133-a101b041ded4/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
golang.org/x/tools v0.0.0-20190706070813-72ffa07ba3db/go.mod h1:jcCCGcm9btYwXyDqrUWc6MKQKKGJCWEQ3AfLSRIbEuI=
golang.org/x/tools v0.0.0-20190719005602-e377ae9d6386/go.mod h1:jcCCGcm9btYwXyDqrUWc6MKQKKGJCWEQ3AfLSRIbEuI=
golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20190910044552-dd2b5c81c578/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20190920225731-5eefd052ad72/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191113232020-e2727e816f5a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200102140908-9497f49d5709/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200204192400-7124308813f3/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
golang.org/x/tools v0.0.0-20200324003944-a576cf524670/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
golang.org/x/tools v0.0.0-20200331202046-9d5940d49312/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200414032229-332987a829c3/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200422022333-3d57cf2e726e/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200426102838-f3a5411a4c3b/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200502202811-ed308ab3e770/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE=
golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
golang.org/x/tools v0.17.0 h1:FvmRgNOcs3kOa+T20R1uhfP9F6HgG2mfxDv1vrx1Htc=
golang.org/x/tools v0.17.0/go.mod h1:xsh6VxdV005rRVaS6SSAf9oiAqljS7UZUacMZ8Bnsps=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20220411194840-2f41105eb62f/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU=
golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90=
gonum.org/v1/gonum v0.0.0-20190331200053-3d26580ed485/go.mod h1:2ltnJ7xHfj0zHS40VVPYEAAMTa3ZGguvHGBSJeRWqE0=
gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw=
gonum.org/v1/netlib v0.0.0-20190331212654-76723241ea4e/go.mod h1:kS+toOQn6AQKjmKJ7gzohV1XkqsFehRA2FbsbkopSuQ=
gonum.org/v1/plot v0.14.0 h1:+LBDVFYwFe4LHhdP8coW6296MBEY4nQ+Y4vuUpJopcE=
gonum.org/v1/plot v0.14.0/go.mod h1:MLdR9424SJed+5VqC6MsouEpig9pZX2VZ57H9ko2bXU=
google.golang.org/api v0.0.0-20160322025152-9bf6e6e569ff/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
google.golang.org/api v0.0.0-20180910000450-7ca32eb868bf/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
google.golang.org/api v0.0.0-20181030000543-1d582fd0359e/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
google.golang.org/api v0.0.0-20181220000619-583d854617af/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
google.golang.org/api v0.2.0/go.mod h1:IfRCZScioGtypHNTlz3gFk67J8uePVW7uDTBzXuIkhU=
google.golang.org/api v0.3.0/go.mod h1:IuvZyQh8jgscv8qWfQ4ABd8m7hEudgBFM/EdhA3BnXw=
google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
google.golang.org/api v0.5.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
google.golang.org/api v0.6.0/go.mod h1:btoxGiFvQNVUZQ8W08zLtrVS08CNpINPEfxXxgJL1Q4=
google.golang.org/api v0.6.1-0.20190607001116-5213b8090861/go.mod h1:btoxGiFvQNVUZQ8W08zLtrVS08CNpINPEfxXxgJL1Q4=
google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
google.golang.org/api v0.25.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=
google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=
google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg=
google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE=
google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8=
google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU=
google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94=
google.golang.org/api v0.47.0/go.mod h1:Wbvgpq1HddcWVtzsVLyfLp8lDg6AA241LmgIL59tHXo=
google.golang.org/api v0.48.0/go.mod h1:71Pr1vy+TAZRPkPs/xlCf5SsU8WjuAWv1Pfjbtukyy4=
google.golang.org/api v0.50.0/go.mod h1:4bNT5pAuq5ji4SRZm+5QIkjny9JAyVD/3gaSihNefaw=
google.golang.org/api v0.51.0/go.mod h1:t4HdrdoNgyN5cbEfm7Lum0lcLDLiise1F8qDKX00sOU=
google.golang.org/api v0.54.0/go.mod h1:7C4bFFOvVDGXjfDTAsgGwDgAxRDeQ4X8NvUedIt6z3k=
google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE=
google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE=
google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI=
google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I=
google.golang.org/api v0.63.0/go.mod h1:gs4ij2ffTRXwuzzgJl/56BdwJaA194ijkfn++9tDuPo=
google.golang.org/api v0.67.0/go.mod h1:ShHKP8E60yPsKNw/w8w+VYaj9H6buA5UqDp8dhbQZ6g=
google.golang.org/api v0.70.0/go.mod h1:Bs4ZM2HGifEvXwd50TtW70ovgJffJYw2oRCOFU/SkfA=
google.golang.org/api v0.71.0/go.mod h1:4PyU6e6JogV1f9eA4voyrTY2batOLdgZ5qZ5HOCc4j8=
google.golang.org/api v0.74.0/go.mod h1:ZpfMZOVRMywNyvJFeqL9HRWBgAuRfSjJFpe9QtRRyDs=
google.golang.org/api v0.75.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA=
google.golang.org/api v0.78.0/go.mod h1:1Sg78yoMLOhlQTeF+ARBoytAcH1NNyyl390YMy6rKmw=
google.golang.org/api v0.80.0/go.mod h1:xY3nI94gbvBrE0J6NHXhxOmW97HG7Khjkku6AFB3Hyg=
google.golang.org/api v0.84.0/go.mod h1:NTsGnUFJMYROtiquksZHBWtHfeMC7iYthki7Eq3pa8o=
google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
google.golang.org/appengine v1.3.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM=
google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds=
google.golang.org/cloud v0.0.0-20151119220103-975617b05ea8/go.mod h1:0H1ncTHf11KCFhTc/+EFRbzSCOZx+VUbRMk55Yv5MYk=
google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
google.golang.org/genproto v0.0.0-20180831171423-11092d34479b/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
google.golang.org/genproto v0.0.0-20181029155118-b69ba1387ce2/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
google.golang.org/genproto v0.0.0-20181219182458-5a97ab628bfb/go.mod h1:7Ep/1NZk928CDR8SjdVbjWNpdIf6nzjE3BTgJDr2Atg=
google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
google.golang.org/genproto v0.0.0-20190508193815-b515fa19cec8/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
google.golang.org/genproto v0.0.0-20190530194941-fb225487d101/go.mod h1:z3L6/3dTEVtUr6QSP8miRzeRqwQOioJ9I66odjN4I7s=
google.golang.org/genproto v0.0.0-20190620144150-6af8c5fc6601/go.mod h1:z3L6/3dTEVtUr6QSP8miRzeRqwQOioJ9I66odjN4I7s=
google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20200117163144-32f20d992d24/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200423170343-7949de9c1215/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
google.golang.org/genproto v0.0.0-20200527145253-8367513e4ece/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/genproto v0.0.0-20210329143202-679c6ae281ee/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A=
google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A=
google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A=
google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
google.golang.org/genproto v0.0.0-20210604141403-392c879c8b08/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
google.golang.org/genproto v0.0.0-20210608205507-b6d2f5bf0d7d/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0=
google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24=
google.golang.org/genproto v0.0.0-20210713002101-d411969a0d9a/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k=
google.golang.org/genproto v0.0.0-20210716133855-ce7ef5c701ea/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k=
google.golang.org/genproto v0.0.0-20210728212813-7823e685a01f/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48=
google.golang.org/genproto v0.0.0-20210805201207-89edb61ffb67/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48=
google.golang.org/genproto v0.0.0-20210813162853-db860fec028c/go.mod h1:cFeNkxwySK631ADgubI+/XFU/xp8FD5KIVV4rj8UC5w=
google.golang.org/genproto v0.0.0-20210821163610-241b8fcbd6c8/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY=
google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20211221195035-429b39de9b1c/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20220126215142-9970aeb2e350/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20220207164111-0872dc986b00/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
google.golang.org/genproto v0.0.0-20220218161850-94dd64e39d7c/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
google.golang.org/genproto v0.0.0-20220222213610-43724f9ea8cf/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
google.golang.org/genproto v0.0.0-20220304144024-325a89244dc8/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
google.golang.org/genproto v0.0.0-20220310185008-1973136f34c6/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI=
google.golang.org/genproto v0.0.0-20220324131243-acbaeb5b85eb/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E=
google.golang.org/genproto v0.0.0-20220407144326-9054f6ed7bac/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
google.golang.org/genproto v0.0.0-20220413183235-5e96e2839df9/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
google.golang.org/genproto v0.0.0-20220414192740-2d67ff6cf2b4/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
google.golang.org/genproto v0.0.0-20220421151946-72621c1f0bd3/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
google.golang.org/genproto v0.0.0-20220429170224-98d788798c3e/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo=
google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
google.golang.org/genproto v0.0.0-20220518221133-4f43b3371335/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
google.golang.org/genproto v0.0.0-20220523171625-347a074981d8/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4=
google.golang.org/genproto v0.0.0-20220608133413-ed9918b62aac/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20220616135557-88e70c0c3a90/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA=
google.golang.org/genproto v0.0.0-20231106174013-bbf56f31fb17 h1:wpZ8pe2x1Q3f2KyT5f8oP/fa9rHAKgFPr/HZdNuS+PQ=
google.golang.org/genproto v0.0.0-20231106174013-bbf56f31fb17/go.mod h1:J7XzRzVy1+IPwWHZUzoD0IccYZIrXILAQpc+Qy9CMhY=
google.golang.org/genproto/googleapis/api v0.0.0-20231106174013-bbf56f31fb17 h1:JpwMPBpFN3uKhdaekDpiNlImDdkUAyiJ6ez/uxGaUSo=
google.golang.org/genproto/googleapis/api v0.0.0-20231106174013-bbf56f31fb17/go.mod h1:0xJLfVdJqpAPl8tDg1ujOCGzx6LFLttXT5NhllGOXY4=
google.golang.org/genproto/googleapis/rpc v0.0.0-20231106174013-bbf56f31fb17 h1:Jyp0Hsi0bmHXG6k9eATXoYtjd6e2UzZ1SCn/wIupY14=
google.golang.org/genproto/googleapis/rpc v0.0.0-20231106174013-bbf56f31fb17/go.mod h1:oQ5rr10WTTMvP4A36n8JpR1OrO1BEiV4f78CneXZxkA=
google.golang.org/grpc v0.0.0-20160317175043-d3ddb4469d5a/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
google.golang.org/grpc v1.16.0/go.mod h1:0JHn/cJsOMiMfNA9+DeHDlAU7KAAB5GDlYFpa9MZMio=
google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
google.golang.org/grpc v1.23.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0=
google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8=
google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
google.golang.org/grpc v1.37.1/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE=
google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE=
google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU=
google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ=
google.golang.org/grpc v1.46.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
google.golang.org/grpc v1.46.2/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk=
google.golang.org/grpc v1.61.0 h1:TOvOcuXn30kRao+gfcvsebNEa5iZIiLkisYEkf7R7o0=
google.golang.org/grpc v1.61.0/go.mod h1:VUbo7IFqmF1QtCAstipjG0GIoq49KvMe9+h1jFLBNJs=
google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw=
google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I=
google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
gopkg.in/airbrake/gobrake.v2 v2.0.9/go.mod h1:/h5ZAUhDkGaJfjzjKLSjv6zCL6O0LLBxU4K+aSYdM/U=
gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20141024133853-64131543e789/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
gopkg.in/cheggaaa/pb.v1 v1.0.25/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw=
gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
gopkg.in/gcfg.v1 v1.2.0/go.mod h1:yesOnuUOFQAhST5vPY4nbZsb/huCgGGXlipJsBn0b3o=
gopkg.in/gemnasium/logrus-airbrake-hook.v2 v2.1.2/go.mod h1:Xk6kEKp8OKb+X14hQBKWaSkCsqBpgog8nAV2xsGOxlo=
gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
gopkg.in/ini.v1 v1.56.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k=
gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
gopkg.in/square/go-jose.v2 v2.2.2/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI=
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
gopkg.in/warnings.v0 v0.1.1/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
gotest.tools/v3 v3.0.2/go.mod h1:3SzNCllyD9/Y+b5r9JIKQ474KzkZyqLqEfYqMsX94Bk=
gotest.tools/v3 v3.5.1 h1:EENdUnS3pdur5nybKYIh2Vfgc8IUNBjxDPSjtiJcOzU=
gotest.tools/v3 v3.5.1/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU=
grpc.go4.org v0.0.0-20170609214715-11d0a25b4919/go.mod h1:77eQGdRu53HpSqPFJFmuJdjuHRquDANNeA4x7B8WQ9o=
honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20180920025451-e3ad64cb4ed3/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
honnef.co/go/tools v0.0.1-2020.1.5/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
k8s.io/api v0.0.0-20180904230853-4e7be11eab3f/go.mod h1:iuAfoD4hCxJ8Onx9kaTIt30j7jUFS00AXQi6QMi99vA=
k8s.io/api v0.17.4/go.mod h1:5qxx6vjmwUVG2nHQTKGlLts8Tbok8PzHl4vHtVFuZCA=
k8s.io/api v0.19.0/go.mod h1:I1K45XlvTrDjmj5LoM5LuP/KYrhWbjUKT/SoPG0qTjw=
k8s.io/apimachinery v0.0.0-20180904193909-def12e63c512/go.mod h1:ccL7Eh7zubPUSh9A3USN90/OzHNSVN6zxzde07TDCL0=
k8s.io/apimachinery v0.17.4/go.mod h1:gxLnyZcGNdZTCLnq3fgzyg2A5BVCHTNDFrw8AmuJ+0g=
k8s.io/apimachinery v0.19.0/go.mod h1:DnPGDnARWFvYa3pMHgSxtbZb7gpzzAZ1pTfaUNDVlmA=
k8s.io/apiserver v0.17.4/go.mod h1:5ZDQ6Xr5MNBxyi3iUZXS84QOhZl+W7Oq2us/29c0j9I=
k8s.io/client-go v0.0.0-20180910083459-2cefa64ff137/go.mod h1:7vJpHMYJwNQCWgzmNV+VYUl1zCObLyodBc8nIyt8L5s=
k8s.io/client-go v0.17.4/go.mod h1:ouF6o5pz3is8qU0/qYL2RnoxOPqgfuidYLowytyLJmc=
k8s.io/client-go v0.19.0/go.mod h1:H9E/VT95blcFQnlyShFgnFT9ZnJOAceiUHM3MlRC+mU=
k8s.io/cloud-provider v0.17.4/go.mod h1:XEjKDzfD+b9MTLXQFlDGkk6Ho8SGMpaU8Uugx/KNK9U=
k8s.io/code-generator v0.17.2/go.mod h1:DVmfPQgxQENqDIzVR2ddLXMH34qeszkKSdH/N+s+38s=
k8s.io/component-base v0.17.4/go.mod h1:5BRqHMbbQPm2kKu35v3G+CpVq4K0RJKC7TRioF0I9lE=
k8s.io/cri-api v0.17.3/go.mod h1:X1sbHmuXhwaHs9xxYffLqJogVsnI+f6cPRcgPel7ywM=
k8s.io/csi-translation-lib v0.17.4/go.mod h1:CsxmjwxEI0tTNMzffIAcgR9lX4wOh6AKHdxQrT7L0oo=
k8s.io/gengo v0.0.0-20190128074634-0689ccc1d7d6/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0=
k8s.io/gengo v0.0.0-20190822140433-26a664648505/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0=
k8s.io/gengo v0.0.0-20200413195148-3a45101e95ac/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0=
k8s.io/klog v0.0.0-20181102134211-b9b56d5dfc92/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk=
k8s.io/klog v0.3.0/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk=
k8s.io/klog v1.0.0/go.mod h1:4Bi6QPql/J/LkTDqv7R/cd3hPo4k2DG6Ptcz060Ez5I=
k8s.io/klog/v2 v2.0.0/go.mod h1:PBfzABfn139FHAV07az/IF9Wp1bkk3vpT2XSJ76fSDE=
k8s.io/klog/v2 v2.2.0/go.mod h1:Od+F08eJP+W3HUb4pSrPpgp9DGU4GzlpG/TmITuYh/Y=
k8s.io/kube-openapi v0.0.0-20180731170545-e3762e86a74c/go.mod h1:BXM9ceUBTj2QnfH2MK1odQs778ajze1RxcmP6S8RVVc=
k8s.io/kube-openapi v0.0.0-20191107075043-30be4d16710a/go.mod h1:1TqjTSzOxsLGIKfj0lK8EeCP7K1iUG65v09OM0/WG5E=
k8s.io/kube-openapi v0.0.0-20200805222855-6aeccd4b50c6/go.mod h1:UuqjUnNftUyPE5H64/qeyjQoUZhGpeFDVdxjTeEVN2o=
k8s.io/kubernetes v1.11.10/go.mod h1:ocZa8+6APFNC2tX1DZASIbocyYT5jHzqFVsY5aoB7Jk=
k8s.io/kubernetes v1.13.0/go.mod h1:ocZa8+6APFNC2tX1DZASIbocyYT5jHzqFVsY5aoB7Jk=
k8s.io/legacy-cloud-providers v0.17.4/go.mod h1:FikRNoD64ECjkxO36gkDgJeiQWwyZTuBkhu+yxOc1Js=
k8s.io/utils v0.0.0-20191114184206-e782cd3c129f/go.mod h1:sZAwmy6armz5eXlNoLmJcl4F1QuKu7sr+mFQ0byX7Ew=
k8s.io/utils v0.0.0-20200729134348-d5654de09c73/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA=
kernel.org/pub/linux/libs/security/libcap/cap v1.2.67 h1:sPQ9qlSNR26fToTKbxe/HDWJlXvBLqGmt84LGCQkOy0=
kernel.org/pub/linux/libs/security/libcap/cap v1.2.67/go.mod h1:GkntoBuwffz19qtdFVB+k2NtWNN+yCKnC/Ykv/hMiTU=
kernel.org/pub/linux/libs/security/libcap/psx v1.2.67 h1:NxbXJ7pDVq0FKBsqjieT92QDXI2XaqH2HAi4QcCOHt8=
kernel.org/pub/linux/libs/security/libcap/psx v1.2.67/go.mod h1:+l6Ee2F59XiJ2I6WR5ObpC1utCQJZ/VLsEbQCD8RG24=
modernc.org/cc v1.0.0/go.mod h1:1Sk4//wdnYJiUIxnW8ddKpaOJCF37yAdqYnkxUpaYxw=
modernc.org/golex v1.0.0/go.mod h1:b/QX9oBD/LhixY6NDh+IdGv17hgB+51fET1i2kPSmvk=
modernc.org/mathutil v1.0.0/go.mod h1:wU0vUrJsVWBZ4P6e7xtFJEhFSNsfRLJ8H458uRjg03k=
modernc.org/strutil v1.0.0/go.mod h1:lstksw84oURvj9y3tn8lGvRxyRC1S2+g5uuIzNfIOBs=
modernc.org/xc v1.0.0/go.mod h1:mRNCo0bvLjGhHO9WsyuKVU4q0ceiDDDoEeWDJHrNx8I=
mvdan.cc/interfacer v0.0.0-20180901003855-c20040233aed/go.mod h1:Xkxe497xwlCKkIaQYRfC7CSLworTXY9RMqwhhCm+8Nc=
mvdan.cc/lint v0.0.0-20170908181259-adc824a0674b/go.mod h1:2odslEg/xrtNQqCYg2/jCoyKnw3vv5biOc3JnIcYfL4=
mvdan.cc/unparam v0.0.0-20190720180237-d51796306d8f/go.mod h1:4G1h5nDURzA3bwVMZIVpwbkw+04kSxk3rAtzlimaUJw=
mvdan.cc/unparam v0.0.0-20200501210554-b37ab49443f7/go.mod h1:HGC5lll35J70Y5v7vCGb9oLhHoScFwkHDJm/05RdSTc=
oss.terrastruct.com/d2 v0.6.1 h1:TEk7pl5yS1cnUxHOsIQ7bZCs+iRGsb5FaofaianfZk8=
oss.terrastruct.com/d2 v0.6.1/go.mod h1:ZyzsiefzsZ3w/BDnfF/hcDx9LKBlgieuolX8pXi7oJY=
oss.terrastruct.com/util-go v0.0.0-20231101220827-55b3812542c2 h1:n6y6RoZCgZDchN4gLGlzNRO1Jdf9xOGGqohDBph5BG8=
oss.terrastruct.com/util-go v0.0.0-20231101220827-55b3812542c2/go.mod h1:eMWv0sOtD9T2RUl90DLWfuShZCYp4NrsqNpI8eqO6U4=
pack.ag/amqp v0.11.2/go.mod h1:4/cbmt4EJXSKlG6LCfWHoqmN0uFdy5i/+YFz+fTfhV4=
rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
rsc.io/pdf v0.1.1 h1:k1MczvYDUvJBe93bYd7wrZLLUEcLZAuF824/I4e5Xr4=
rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
sigs.k8s.io/structured-merge-diff v0.0.0-20190525122527-15d366b2352e/go.mod h1:wWxsB5ozmmv/SG7nM11ayaAW51xMvak/t1r0CSlcokI=
sigs.k8s.io/structured-merge-diff v1.0.1-0.20191108220359-b1b620dd3f06/go.mod h1:/ULNhyfzRopfcjskuui0cTITekDduZ7ycKN3oUT9R18=
sigs.k8s.io/structured-merge-diff/v4 v4.0.1/go.mod h1:bJZC9H9iH24zzfZ/41RGcq60oK1F7G282QMXDPYydCw=
sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=
sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc=
sigs.k8s.io/yaml v1.3.0/go.mod h1:GeOyir5tyXNByN85N/dRIT9es5UQNerPYEKK56eTBm8=
sourcegraph.com/sqs/pbtypes v0.0.0-20180604144634-d3ebe8f20ae4/go.mod h1:ketZ/q3QxT9HOBeFhu6RdvsftgpsbFHBF5Cas6cDKZ0=
sourcegraph.com/sqs/pbtypes v1.0.0/go.mod h1:3AciMUv4qUuRHRHhOG4TZOB+72GdPVz5k+c648qsFS4=
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,850 | 🐞 v0.10.1 Client panic when with Pipeline | ### What is the issue?
The generated code missing the private `graphql.Client`
https://github.com/dagger/dagger/blob/v0.10.1/sdk/go/dagger.gen.go#L5580-L5597
https://github.com/dagger/dagger/blob/v0.10.0/sdk/go/dagger.gen.go#L5745-L5763
### Dagger version
v0.10.1
### Steps to reproduce
_No response_
### Log output
_No response_ | https://github.com/dagger/dagger/issues/6850 | https://github.com/dagger/dagger/pull/6851 | ea653ee3a1fd32d5ecbcec3448240cf51f8a5251 | c1b0b5bf50557e50f42ca4ca0538bc7cdb672b3f | "2024-03-07T13:54:40Z" | go | "2024-03-08T09:38:41Z" | cmd/codegen/generator/go/templates/src/_types/object.go.tmpl | {{- if ne .Name "Query" }}
{{ .Description | Comment }}
type {{ .Name | FormatName }} struct {
Query *querybuilder.Selection
{{ range $field := .Fields }}
{{- if $field.TypeRef.IsScalar }}
{{ $field.Name }} *{{ $field.TypeRef | FormatOutputType }}
{{- end }}
{{- end }}
}
{{- end }}
{{- if . | IsSelfChainable }}
type With{{ .Name | FormatName }}Func func(r *{{ .Name | FormatName }}) *{{ .Name | FormatName }}
// With calls the provided function with current {{ .Name | FormatName }}.
//
// This is useful for reusability and readability by not breaking the calling chain.
func (r *{{ $.Name | FormatName }}) With(f With{{ .Name | FormatName }}Func) *{{ $.Name | FormatName }} {
return f(r)
}
{{- end }}
{{ range $field := .Fields }}
{{- if $field.Args.HasOptionals }}
// {{ $field | FieldOptionsStructName }} contains options for {{ $.Name | FormatName }}.{{ $field.Name | FormatName }}
type {{ $field | FieldOptionsStructName }} struct {
{{- range $arg := $field.Args }}
{{- if $arg.TypeRef.IsOptional }}
{{ $arg.Description | Comment }}
{{- if and (eq $arg.Name "id") (eq $.Name "Query") }}
{{ $arg.Name | FormatName }} {{ $arg.TypeRef | FormatOutputType }}
{{- else }}
{{ $arg.Name | FormatName }} {{ $arg.TypeRef | FormatInputType }}
{{- end }}
{{- end }}
{{- end }}
}
{{- end }}
{{ $field.Description | Comment }}
{{- if $field.IsDeprecated }}
//
{{ $field.DeprecationReason | FormatDeprecation }}
{{- end }}
{{- $convertID := $field | ConvertID }}
{{ FieldFunction $field false }} {
{{- range $arg := $field.Args }}
{{- if and (IsPointer $arg) (not $arg.TypeRef.IsOptional) }}
assertNotNil("{{ $arg.Name}}", {{ $arg.Name }})
{{- end }}
{{- end }}
{{- if and ($field.TypeRef.IsScalar) (ne $field.ParentObject.Name "Query") (not $convertID) }}
if r.{{ $field.Name }} != nil {
return *r.{{ $field.Name }}, nil
}
{{- end }}
q := r.Query.Select("{{ $field.Name }}")
{{- if $field.Args.HasOptionals }}
for i := len(opts) - 1; i >= 0; i-- {
{{- range $arg := $field.Args }}
{{- if $arg.TypeRef.IsOptional }}
// `{{ $arg.Name }}` optional argument
if !querybuilder.IsZeroValue(opts[i].{{ $arg.Name | FormatName }}) {
q = q.Arg("{{ $arg.Name }}", opts[i].{{ $arg.Name | FormatName }})
}
{{- end }}
{{- end }}
}
{{- end }}
{{- range $arg := $field.Args }}
{{- if not $arg.TypeRef.IsOptional }}
q = q.Arg("{{ $arg.Name }}", {{ $arg.Name }})
{{- end }}
{{- end }}
{{ if $convertID }}
return r, q.Execute(ctx)
{{- else if $field.TypeRef.IsObject }}
{{ $typeName := $field.TypeRef | FormatOutputType }}
return &{{ $field.TypeRef | FormatOutputType }} {
Query: q,
}
{{- else if or $field.TypeRef.IsScalar $field.TypeRef.IsList }}
{{- if and $field.TypeRef.IsList (IsListOfObject $field.TypeRef) }}
q = q.Select("{{ range $i, $v := $field | GetArrayField }}{{ if $i }} {{ end }}{{ $v.Name }}{{ end }}")
type {{ $field.Name | ToLowerCase }} struct {
{{ range $v := $field | GetArrayField }}
{{ $v.Name | ToUpperCase }} {{ $v.TypeRef | FormatOutputType }}
{{- end }}
}
{{$eleType := $field.TypeRef | InnerType}}
convert := func(fields []{{ $field.Name | ToLowerCase }}) {{ $field.TypeRef | FormatOutputType }} {
out := {{ $field.TypeRef | FormatOutputType }}{}
for i := range fields {
val := {{ $field.TypeRef | FormatOutputType | FormatArrayToSingleType }}{{"{"}}{{ $field | GetArrayField | FormatArrayField }}{{"}"}}
{{- if $eleType | IsIDableObject }}
val.Query = q.Root().Select("load{{$eleType | ObjectName}}FromID").Arg("id", fields[i].Id)
{{- end }}
out = append(out, val)
}
return out
}
{{- end }}
{{- if and $field.TypeRef.IsList (IsListOfObject $field.TypeRef) }}
var response []{{ $field.Name | ToLowerCase }}
{{- else }}
var response {{ $field.TypeRef | FormatOutputType }}
{{- end }}
q = q.Bind(&response)
{{- $typeName := $field.TypeRef | FormatOutputType }}
{{- if ne $typeName "Client" }}
{{- if and $field.TypeRef.IsList (IsListOfObject $field.TypeRef) }}
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
{{- else }}
return response, q.Execute(ctx)
{{- end }}
{{- else }}
return response, q.Execute(ctx, r.gql)
{{- end }}
{{- end }}
}
{{ if eq $field.Name "id" }}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *{{ $.Name | FormatName }}) XXX_GraphQLType() string {
return "{{ $.Name }}"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *{{ $.Name | FormatName }}) XXX_GraphQLIDType() string {
return "{{ $field.TypeRef | FormatOutputType }}"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *{{ $.Name | FormatName }}) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *{{ $.Name | FormatName }}) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
{{- if IsModuleCode }}
func (r *{{ $.Name | FormatName }}) UnmarshalJSON(bs []byte) error {
var id string
err := json.Unmarshal(bs, &id)
if err != nil {
return err
}
*r = *dag.Load{{ $.Name | FormatName }}FromID({{$.Name | FormatName}}ID(id))
return nil
}
{{- end }}
{{ end }}
{{ end -}}
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,850 | 🐞 v0.10.1 Client panic when with Pipeline | ### What is the issue?
The generated code missing the private `graphql.Client`
https://github.com/dagger/dagger/blob/v0.10.1/sdk/go/dagger.gen.go#L5580-L5597
https://github.com/dagger/dagger/blob/v0.10.0/sdk/go/dagger.gen.go#L5745-L5763
### Dagger version
v0.10.1
### Steps to reproduce
_No response_
### Log output
_No response_ | https://github.com/dagger/dagger/issues/6850 | https://github.com/dagger/dagger/pull/6851 | ea653ee3a1fd32d5ecbcec3448240cf51f8a5251 | c1b0b5bf50557e50f42ca4ca0538bc7cdb672b3f | "2024-03-07T13:54:40Z" | go | "2024-03-08T09:38:41Z" | core/integration/pipeline_test.go | package core
import (
"fmt"
"testing"
"time"
"dagger.io/dagger"
"github.com/stretchr/testify/require"
)
func TestPipeline(t *testing.T) {
t.Parallel()
cacheBuster := fmt.Sprintf("%d", time.Now().UTC().UnixNano())
t.Run("container pipeline", func(t *testing.T) {
t.Parallel()
var logs safeBuffer
c, ctx := connect(t, dagger.WithLogOutput(&logs))
_, err := c.
Container().
Pipeline("container pipeline").
From(alpineImage).
WithExec([]string{"echo", cacheBuster}).
Sync(ctx)
require.NoError(t, err)
require.NoError(t, c.Close()) // close + flush logs
t.Log(logs.String())
require.Contains(t, logs.String(), "container pipeline")
})
t.Run("directory pipeline", func(t *testing.T) {
t.Parallel()
var logs safeBuffer
c, ctx := connect(t, dagger.WithLogOutput(&logs))
contents, err := c.
Directory().
Pipeline("directory pipeline").
WithNewFile("/foo", cacheBuster).
File("/foo").
Contents(ctx)
require.NoError(t, err)
require.Equal(t, contents, cacheBuster)
require.NoError(t, c.Close()) // close + flush logs
t.Log(logs.String())
require.Contains(t, logs.String(), "directory pipeline")
})
t.Run("service pipeline", func(t *testing.T) {
t.Parallel()
var logs safeBuffer
c, ctx := connect(t, dagger.WithLogOutput(&logs))
srv, url := httpService(ctx, t, c, "Hello, world!")
hostname, err := srv.Hostname(ctx)
require.NoError(t, err)
client := c.Container().
From(alpineImage).
WithServiceBinding("www", srv).
WithExec([]string{"apk", "add", "curl"}).
WithExec([]string{"curl", "-v", url})
_, err = client.Sync(ctx)
require.NoError(t, err)
_, err = srv.Stop(ctx) // FIXME: shouldn't need this, but test is flaking
require.NoError(t, err)
require.NoError(t, c.Close()) // close + flush logs
t.Log(logs.String())
require.Contains(t, logs.String(), "service "+hostname)
require.Regexp(t, `start python -m http.server.*DONE`, logs.String())
})
}
func TestInternalVertexes(t *testing.T) {
t.Parallel()
cacheBuster := fmt.Sprintf("%d", time.Now().UTC().UnixNano())
t.Run("merge pipeline", func(t *testing.T) {
t.Parallel()
var logs safeBuffer
c, ctx := connect(t, dagger.WithLogOutput(&logs))
dirA := c.Directory().WithNewFile("/foo", "foo")
dirB := c.Directory().WithNewFile("/bar", "bar")
_, err := c.
Container().
From(alpineImage).
WithDirectory("/foo", dirA).
WithDirectory("/bar", dirB).
WithExec([]string{"echo", cacheBuster}).
Sync(ctx)
require.NoError(t, err)
require.NoError(t, c.Close()) // close + flush logs
require.NotContains(t, logs.String(), "merge (")
})
}
|
closed | dagger/dagger | https://github.com/dagger/dagger | 6,850 | 🐞 v0.10.1 Client panic when with Pipeline | ### What is the issue?
The generated code missing the private `graphql.Client`
https://github.com/dagger/dagger/blob/v0.10.1/sdk/go/dagger.gen.go#L5580-L5597
https://github.com/dagger/dagger/blob/v0.10.0/sdk/go/dagger.gen.go#L5745-L5763
### Dagger version
v0.10.1
### Steps to reproduce
_No response_
### Log output
_No response_ | https://github.com/dagger/dagger/issues/6850 | https://github.com/dagger/dagger/pull/6851 | ea653ee3a1fd32d5ecbcec3448240cf51f8a5251 | c1b0b5bf50557e50f42ca4ca0538bc7cdb672b3f | "2024-03-07T13:54:40Z" | go | "2024-03-08T09:38:41Z" | sdk/go/dagger.gen.go | // Code generated by dagger. DO NOT EDIT.
package dagger
import (
"context"
"encoding/json"
"errors"
"fmt"
"reflect"
"strings"
"github.com/vektah/gqlparser/v2/gqlerror"
"dagger.io/dagger/querybuilder"
)
// assertNotNil panic if the given value is nil.
// This function is used to validate that input with pointer type are not nil.
// See https://github.com/dagger/dagger/issues/5696 for more context.
func assertNotNil(argName string, value any) {
// We use reflect because just comparing value to nil is not working since
// the value is wrapped into a type when passed as parameter.
// E.g., nil become (*dagger.File)(nil).
if reflect.ValueOf(value).IsNil() {
panic(fmt.Sprintf("unexpected nil pointer for argument %q", argName))
}
}
type DaggerObject querybuilder.GraphQLMarshaller
// getCustomError parses a GraphQL error into a more specific error type.
func getCustomError(err error) error {
var gqlErr *gqlerror.Error
if !errors.As(err, &gqlErr) {
return nil
}
ext := gqlErr.Extensions
typ, ok := ext["_type"].(string)
if !ok {
return nil
}
if typ == "EXEC_ERROR" {
e := &ExecError{
original: err,
}
if code, ok := ext["exitCode"].(float64); ok {
e.ExitCode = int(code)
}
if args, ok := ext["cmd"].([]interface{}); ok {
cmd := make([]string, len(args))
for i, v := range args {
cmd[i] = v.(string)
}
e.Cmd = cmd
}
if stdout, ok := ext["stdout"].(string); ok {
e.Stdout = stdout
}
if stderr, ok := ext["stderr"].(string); ok {
e.Stderr = stderr
}
return e
}
return nil
}
// ExecError is an API error from an exec operation.
type ExecError struct {
original error
Cmd []string
ExitCode int
Stdout string
Stderr string
}
func (e *ExecError) Error() string {
// As a default when just printing the error, include the stdout
// and stderr for visibility
msg := e.Message()
if strings.TrimSpace(e.Stdout) != "" {
msg += "\nStdout:\n" + e.Stdout
}
if strings.TrimSpace(e.Stderr) != "" {
msg += "\nStderr:\n" + e.Stderr
}
return msg
}
func (e *ExecError) Message() string {
return e.original.Error()
}
func (e *ExecError) Unwrap() error {
return e.original
}
// The `CacheVolumeID` scalar type represents an identifier for an object of type CacheVolume.
type CacheVolumeID string
// The `ContainerID` scalar type represents an identifier for an object of type Container.
type ContainerID string
// The `CurrentModuleID` scalar type represents an identifier for an object of type CurrentModule.
type CurrentModuleID string
// The `DirectoryID` scalar type represents an identifier for an object of type Directory.
type DirectoryID string
// The `EnvVariableID` scalar type represents an identifier for an object of type EnvVariable.
type EnvVariableID string
// The `FieldTypeDefID` scalar type represents an identifier for an object of type FieldTypeDef.
type FieldTypeDefID string
// The `FileID` scalar type represents an identifier for an object of type File.
type FileID string
// The `FunctionArgID` scalar type represents an identifier for an object of type FunctionArg.
type FunctionArgID string
// The `FunctionCallArgValueID` scalar type represents an identifier for an object of type FunctionCallArgValue.
type FunctionCallArgValueID string
// The `FunctionCallID` scalar type represents an identifier for an object of type FunctionCall.
type FunctionCallID string
// The `FunctionID` scalar type represents an identifier for an object of type Function.
type FunctionID string
// The `GeneratedCodeID` scalar type represents an identifier for an object of type GeneratedCode.
type GeneratedCodeID string
// The `GitModuleSourceID` scalar type represents an identifier for an object of type GitModuleSource.
type GitModuleSourceID string
// The `GitRefID` scalar type represents an identifier for an object of type GitRef.
type GitRefID string
// The `GitRepositoryID` scalar type represents an identifier for an object of type GitRepository.
type GitRepositoryID string
// The `HostID` scalar type represents an identifier for an object of type Host.
type HostID string
// The `InputTypeDefID` scalar type represents an identifier for an object of type InputTypeDef.
type InputTypeDefID string
// The `InterfaceTypeDefID` scalar type represents an identifier for an object of type InterfaceTypeDef.
type InterfaceTypeDefID string
// An arbitrary JSON-encoded value.
type JSON string
// The `LabelID` scalar type represents an identifier for an object of type Label.
type LabelID string
// The `ListTypeDefID` scalar type represents an identifier for an object of type ListTypeDef.
type ListTypeDefID string
// The `LocalModuleSourceID` scalar type represents an identifier for an object of type LocalModuleSource.
type LocalModuleSourceID string
// The `ModuleDependencyID` scalar type represents an identifier for an object of type ModuleDependency.
type ModuleDependencyID string
// The `ModuleID` scalar type represents an identifier for an object of type Module.
type ModuleID string
// The `ModuleSourceID` scalar type represents an identifier for an object of type ModuleSource.
type ModuleSourceID string
// The `ObjectTypeDefID` scalar type represents an identifier for an object of type ObjectTypeDef.
type ObjectTypeDefID string
// The platform config OS and architecture in a Container.
//
// The format is [os]/[platform]/[version] (e.g., "darwin/arm64/v7", "windows/amd64", "linux/arm64").
type Platform string
// The `PortID` scalar type represents an identifier for an object of type Port.
type PortID string
// The `SecretID` scalar type represents an identifier for an object of type Secret.
type SecretID string
// The `ServiceID` scalar type represents an identifier for an object of type Service.
type ServiceID string
// The `SocketID` scalar type represents an identifier for an object of type Socket.
type SocketID string
// The `TerminalID` scalar type represents an identifier for an object of type Terminal.
type TerminalID string
// The `TypeDefID` scalar type represents an identifier for an object of type TypeDef.
type TypeDefID string
// The absence of a value.
//
// A Null Void is used as a placeholder for resolvers that do not return anything.
type Void string
// Key value object that represents a build argument.
type BuildArg struct {
// The build argument name.
Name string `json:"name"`
// The build argument value.
Value string `json:"value"`
}
// Key value object that represents a pipeline label.
type PipelineLabel struct {
// Label name.
Name string `json:"name"`
// Label value.
Value string `json:"value"`
}
// Port forwarding rules for tunneling network traffic.
type PortForward struct {
// Destination port for traffic.
Backend int `json:"backend"`
// Port to expose to clients. If unspecified, a default will be chosen.
Frontend int `json:"frontend"`
// Transport layer protocol to use for traffic.
Protocol NetworkProtocol `json:"protocol,omitempty"`
}
// A directory whose contents persist across runs.
type CacheVolume struct {
Query *querybuilder.Selection
id *CacheVolumeID
}
// A unique identifier for this CacheVolume.
func (r *CacheVolume) ID(ctx context.Context) (CacheVolumeID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response CacheVolumeID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *CacheVolume) XXX_GraphQLType() string {
return "CacheVolume"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *CacheVolume) XXX_GraphQLIDType() string {
return "CacheVolumeID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *CacheVolume) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *CacheVolume) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// An OCI-compatible container, also known as a Docker container.
type Container struct {
Query *querybuilder.Selection
envVariable *string
export *bool
id *ContainerID
imageRef *string
label *string
platform *Platform
publish *string
stderr *string
stdout *string
sync *ContainerID
user *string
workdir *string
}
type WithContainerFunc func(r *Container) *Container
// With calls the provided function with current Container.
//
// This is useful for reusability and readability by not breaking the calling chain.
func (r *Container) With(f WithContainerFunc) *Container {
return f(r)
}
// Turn the container into a Service.
//
// Be sure to set any exposed ports before this conversion.
func (r *Container) AsService() *Service {
q := r.Query.Select("asService")
return &Service{
Query: q,
}
}
// ContainerAsTarballOpts contains options for Container.AsTarball
type ContainerAsTarballOpts struct {
// Identifiers for other platform specific containers.
//
// Used for multi-platform images.
PlatformVariants []*Container
// Force each layer of the image to use the specified compression algorithm.
//
// If this is unset, then if a layer already has a compressed blob in the engine's cache, that will be used (this can result in a mix of compression algorithms for different layers). If this is unset and a layer has no compressed blob in the engine's cache, then it will be compressed using Gzip.
ForcedCompression ImageLayerCompression
// Use the specified media types for the image's layers.
//
// Defaults to OCI, which is largely compatible with most recent container runtimes, but Docker may be needed for older runtimes without OCI support.
MediaTypes ImageMediaTypes
}
// Returns a File representing the container serialized to a tarball.
func (r *Container) AsTarball(opts ...ContainerAsTarballOpts) *File {
q := r.Query.Select("asTarball")
for i := len(opts) - 1; i >= 0; i-- {
// `platformVariants` optional argument
if !querybuilder.IsZeroValue(opts[i].PlatformVariants) {
q = q.Arg("platformVariants", opts[i].PlatformVariants)
}
// `forcedCompression` optional argument
if !querybuilder.IsZeroValue(opts[i].ForcedCompression) {
q = q.Arg("forcedCompression", opts[i].ForcedCompression)
}
// `mediaTypes` optional argument
if !querybuilder.IsZeroValue(opts[i].MediaTypes) {
q = q.Arg("mediaTypes", opts[i].MediaTypes)
}
}
return &File{
Query: q,
}
}
// ContainerBuildOpts contains options for Container.Build
type ContainerBuildOpts struct {
// Path to the Dockerfile to use.
Dockerfile string
// Target build stage to build.
Target string
// Additional build arguments.
BuildArgs []BuildArg
// Secrets to pass to the build.
//
// They will be mounted at /run/secrets/[secret-name] in the build container
//
// They can be accessed in the Dockerfile using the "secret" mount type and mount path /run/secrets/[secret-name], e.g. RUN --mount=type=secret,id=my-secret curl [http://example.com?token=$(cat /run/secrets/my-secret)](http://example.com?token=$(cat /run/secrets/my-secret))
Secrets []*Secret
}
// Initializes this container from a Dockerfile build.
func (r *Container) Build(context *Directory, opts ...ContainerBuildOpts) *Container {
assertNotNil("context", context)
q := r.Query.Select("build")
for i := len(opts) - 1; i >= 0; i-- {
// `dockerfile` optional argument
if !querybuilder.IsZeroValue(opts[i].Dockerfile) {
q = q.Arg("dockerfile", opts[i].Dockerfile)
}
// `target` optional argument
if !querybuilder.IsZeroValue(opts[i].Target) {
q = q.Arg("target", opts[i].Target)
}
// `buildArgs` optional argument
if !querybuilder.IsZeroValue(opts[i].BuildArgs) {
q = q.Arg("buildArgs", opts[i].BuildArgs)
}
// `secrets` optional argument
if !querybuilder.IsZeroValue(opts[i].Secrets) {
q = q.Arg("secrets", opts[i].Secrets)
}
}
q = q.Arg("context", context)
return &Container{
Query: q,
}
}
// Retrieves default arguments for future commands.
func (r *Container) DefaultArgs(ctx context.Context) ([]string, error) {
q := r.Query.Select("defaultArgs")
var response []string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Retrieves a directory at the given path.
//
// Mounts are included.
func (r *Container) Directory(path string) *Directory {
q := r.Query.Select("directory")
q = q.Arg("path", path)
return &Directory{
Query: q,
}
}
// Retrieves entrypoint to be prepended to the arguments of all commands.
func (r *Container) Entrypoint(ctx context.Context) ([]string, error) {
q := r.Query.Select("entrypoint")
var response []string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Retrieves the value of the specified environment variable.
func (r *Container) EnvVariable(ctx context.Context, name string) (string, error) {
if r.envVariable != nil {
return *r.envVariable, nil
}
q := r.Query.Select("envVariable")
q = q.Arg("name", name)
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Retrieves the list of environment variables passed to commands.
func (r *Container) EnvVariables(ctx context.Context) ([]EnvVariable, error) {
q := r.Query.Select("envVariables")
q = q.Select("id")
type envVariables struct {
Id EnvVariableID
}
convert := func(fields []envVariables) []EnvVariable {
out := []EnvVariable{}
for i := range fields {
val := EnvVariable{id: &fields[i].Id}
val.Query = q.Root().Select("loadEnvVariableFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []envVariables
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// EXPERIMENTAL API! Subject to change/removal at any time.
//
// Configures all available GPUs on the host to be accessible to this container.
//
// This currently works for Nvidia devices only.
func (r *Container) ExperimentalWithAllGPUs() *Container {
q := r.Query.Select("experimentalWithAllGPUs")
return &Container{
Query: q,
}
}
// EXPERIMENTAL API! Subject to change/removal at any time.
//
// Configures the provided list of devices to be accesible to this container.
//
// This currently works for Nvidia devices only.
func (r *Container) ExperimentalWithGPU(devices []string) *Container {
q := r.Query.Select("experimentalWithGPU")
q = q.Arg("devices", devices)
return &Container{
Query: q,
}
}
// ContainerExportOpts contains options for Container.Export
type ContainerExportOpts struct {
// Identifiers for other platform specific containers.
//
// Used for multi-platform image.
PlatformVariants []*Container
// Force each layer of the exported image to use the specified compression algorithm.
//
// If this is unset, then if a layer already has a compressed blob in the engine's cache, that will be used (this can result in a mix of compression algorithms for different layers). If this is unset and a layer has no compressed blob in the engine's cache, then it will be compressed using Gzip.
ForcedCompression ImageLayerCompression
// Use the specified media types for the exported image's layers.
//
// Defaults to OCI, which is largely compatible with most recent container runtimes, but Docker may be needed for older runtimes without OCI support.
MediaTypes ImageMediaTypes
}
// Writes the container as an OCI tarball to the destination file path on the host.
//
// Return true on success.
//
// It can also export platform variants.
func (r *Container) Export(ctx context.Context, path string, opts ...ContainerExportOpts) (bool, error) {
if r.export != nil {
return *r.export, nil
}
q := r.Query.Select("export")
for i := len(opts) - 1; i >= 0; i-- {
// `platformVariants` optional argument
if !querybuilder.IsZeroValue(opts[i].PlatformVariants) {
q = q.Arg("platformVariants", opts[i].PlatformVariants)
}
// `forcedCompression` optional argument
if !querybuilder.IsZeroValue(opts[i].ForcedCompression) {
q = q.Arg("forcedCompression", opts[i].ForcedCompression)
}
// `mediaTypes` optional argument
if !querybuilder.IsZeroValue(opts[i].MediaTypes) {
q = q.Arg("mediaTypes", opts[i].MediaTypes)
}
}
q = q.Arg("path", path)
var response bool
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Retrieves the list of exposed ports.
//
// This includes ports already exposed by the image, even if not explicitly added with dagger.
func (r *Container) ExposedPorts(ctx context.Context) ([]Port, error) {
q := r.Query.Select("exposedPorts")
q = q.Select("id")
type exposedPorts struct {
Id PortID
}
convert := func(fields []exposedPorts) []Port {
out := []Port{}
for i := range fields {
val := Port{id: &fields[i].Id}
val.Query = q.Root().Select("loadPortFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []exposedPorts
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// Retrieves a file at the given path.
//
// Mounts are included.
func (r *Container) File(path string) *File {
q := r.Query.Select("file")
q = q.Arg("path", path)
return &File{
Query: q,
}
}
// Initializes this container from a pulled base image.
func (r *Container) From(address string) *Container {
q := r.Query.Select("from")
q = q.Arg("address", address)
return &Container{
Query: q,
}
}
// A unique identifier for this Container.
func (r *Container) ID(ctx context.Context) (ContainerID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response ContainerID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *Container) XXX_GraphQLType() string {
return "Container"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *Container) XXX_GraphQLIDType() string {
return "ContainerID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *Container) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Container) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The unique image reference which can only be retrieved immediately after the 'Container.From' call.
func (r *Container) ImageRef(ctx context.Context) (string, error) {
if r.imageRef != nil {
return *r.imageRef, nil
}
q := r.Query.Select("imageRef")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// ContainerImportOpts contains options for Container.Import
type ContainerImportOpts struct {
// Identifies the tag to import from the archive, if the archive bundles multiple tags.
Tag string
}
// Reads the container from an OCI tarball.
func (r *Container) Import(source *File, opts ...ContainerImportOpts) *Container {
assertNotNil("source", source)
q := r.Query.Select("import")
for i := len(opts) - 1; i >= 0; i-- {
// `tag` optional argument
if !querybuilder.IsZeroValue(opts[i].Tag) {
q = q.Arg("tag", opts[i].Tag)
}
}
q = q.Arg("source", source)
return &Container{
Query: q,
}
}
// Retrieves the value of the specified label.
func (r *Container) Label(ctx context.Context, name string) (string, error) {
if r.label != nil {
return *r.label, nil
}
q := r.Query.Select("label")
q = q.Arg("name", name)
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Retrieves the list of labels passed to container.
func (r *Container) Labels(ctx context.Context) ([]Label, error) {
q := r.Query.Select("labels")
q = q.Select("id")
type labels struct {
Id LabelID
}
convert := func(fields []labels) []Label {
out := []Label{}
for i := range fields {
val := Label{id: &fields[i].Id}
val.Query = q.Root().Select("loadLabelFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []labels
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// Retrieves the list of paths where a directory is mounted.
func (r *Container) Mounts(ctx context.Context) ([]string, error) {
q := r.Query.Select("mounts")
var response []string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// ContainerPipelineOpts contains options for Container.Pipeline
type ContainerPipelineOpts struct {
// Description of the sub-pipeline.
Description string
// Labels to apply to the sub-pipeline.
Labels []PipelineLabel
}
// Creates a named sub-pipeline.
func (r *Container) Pipeline(name string, opts ...ContainerPipelineOpts) *Container {
q := r.Query.Select("pipeline")
for i := len(opts) - 1; i >= 0; i-- {
// `description` optional argument
if !querybuilder.IsZeroValue(opts[i].Description) {
q = q.Arg("description", opts[i].Description)
}
// `labels` optional argument
if !querybuilder.IsZeroValue(opts[i].Labels) {
q = q.Arg("labels", opts[i].Labels)
}
}
q = q.Arg("name", name)
return &Container{
Query: q,
}
}
// The platform this container executes and publishes as.
func (r *Container) Platform(ctx context.Context) (Platform, error) {
if r.platform != nil {
return *r.platform, nil
}
q := r.Query.Select("platform")
var response Platform
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// ContainerPublishOpts contains options for Container.Publish
type ContainerPublishOpts struct {
// Identifiers for other platform specific containers.
//
// Used for multi-platform image.
PlatformVariants []*Container
// Force each layer of the published image to use the specified compression algorithm.
//
// If this is unset, then if a layer already has a compressed blob in the engine's cache, that will be used (this can result in a mix of compression algorithms for different layers). If this is unset and a layer has no compressed blob in the engine's cache, then it will be compressed using Gzip.
ForcedCompression ImageLayerCompression
// Use the specified media types for the published image's layers.
//
// Defaults to OCI, which is largely compatible with most recent registries, but Docker may be needed for older registries without OCI support.
MediaTypes ImageMediaTypes
}
// Publishes this container as a new image to the specified address.
//
// Publish returns a fully qualified ref.
//
// It can also publish platform variants.
func (r *Container) Publish(ctx context.Context, address string, opts ...ContainerPublishOpts) (string, error) {
if r.publish != nil {
return *r.publish, nil
}
q := r.Query.Select("publish")
for i := len(opts) - 1; i >= 0; i-- {
// `platformVariants` optional argument
if !querybuilder.IsZeroValue(opts[i].PlatformVariants) {
q = q.Arg("platformVariants", opts[i].PlatformVariants)
}
// `forcedCompression` optional argument
if !querybuilder.IsZeroValue(opts[i].ForcedCompression) {
q = q.Arg("forcedCompression", opts[i].ForcedCompression)
}
// `mediaTypes` optional argument
if !querybuilder.IsZeroValue(opts[i].MediaTypes) {
q = q.Arg("mediaTypes", opts[i].MediaTypes)
}
}
q = q.Arg("address", address)
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Retrieves this container's root filesystem. Mounts are not included.
func (r *Container) Rootfs() *Directory {
q := r.Query.Select("rootfs")
return &Directory{
Query: q,
}
}
// The error stream of the last executed command.
//
// Will execute default command if none is set, or error if there's no default.
func (r *Container) Stderr(ctx context.Context) (string, error) {
if r.stderr != nil {
return *r.stderr, nil
}
q := r.Query.Select("stderr")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The output stream of the last executed command.
//
// Will execute default command if none is set, or error if there's no default.
func (r *Container) Stdout(ctx context.Context) (string, error) {
if r.stdout != nil {
return *r.stdout, nil
}
q := r.Query.Select("stdout")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Forces evaluation of the pipeline in the engine.
//
// It doesn't run the default command if no exec has been set.
func (r *Container) Sync(ctx context.Context) (*Container, error) {
q := r.Query.Select("sync")
return r, q.Execute(ctx)
}
// ContainerTerminalOpts contains options for Container.Terminal
type ContainerTerminalOpts struct {
// If set, override the container's default terminal command and invoke these command arguments instead.
Cmd []string
// Provides Dagger access to the executed command.
//
// Do not use this option unless you trust the command being executed; the command being executed WILL BE GRANTED FULL ACCESS TO YOUR HOST FILESYSTEM.
ExperimentalPrivilegedNesting bool
// Execute the command with all root capabilities. This is similar to running a command with "sudo" or executing "docker run" with the "--privileged" flag. Containerization does not provide any security guarantees when using this option. It should only be used when absolutely necessary and only with trusted commands.
InsecureRootCapabilities bool
}
// Return an interactive terminal for this container using its configured default terminal command if not overridden by args (or sh as a fallback default).
func (r *Container) Terminal(opts ...ContainerTerminalOpts) *Terminal {
q := r.Query.Select("terminal")
for i := len(opts) - 1; i >= 0; i-- {
// `cmd` optional argument
if !querybuilder.IsZeroValue(opts[i].Cmd) {
q = q.Arg("cmd", opts[i].Cmd)
}
// `experimentalPrivilegedNesting` optional argument
if !querybuilder.IsZeroValue(opts[i].ExperimentalPrivilegedNesting) {
q = q.Arg("experimentalPrivilegedNesting", opts[i].ExperimentalPrivilegedNesting)
}
// `insecureRootCapabilities` optional argument
if !querybuilder.IsZeroValue(opts[i].InsecureRootCapabilities) {
q = q.Arg("insecureRootCapabilities", opts[i].InsecureRootCapabilities)
}
}
return &Terminal{
Query: q,
}
}
// Retrieves the user to be set for all commands.
func (r *Container) User(ctx context.Context) (string, error) {
if r.user != nil {
return *r.user, nil
}
q := r.Query.Select("user")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Configures default arguments for future commands.
func (r *Container) WithDefaultArgs(args []string) *Container {
q := r.Query.Select("withDefaultArgs")
q = q.Arg("args", args)
return &Container{
Query: q,
}
}
// ContainerWithDefaultTerminalCmdOpts contains options for Container.WithDefaultTerminalCmd
type ContainerWithDefaultTerminalCmdOpts struct {
// Provides Dagger access to the executed command.
//
// Do not use this option unless you trust the command being executed; the command being executed WILL BE GRANTED FULL ACCESS TO YOUR HOST FILESYSTEM.
ExperimentalPrivilegedNesting bool
// Execute the command with all root capabilities. This is similar to running a command with "sudo" or executing "docker run" with the "--privileged" flag. Containerization does not provide any security guarantees when using this option. It should only be used when absolutely necessary and only with trusted commands.
InsecureRootCapabilities bool
}
// Set the default command to invoke for the container's terminal API.
func (r *Container) WithDefaultTerminalCmd(args []string, opts ...ContainerWithDefaultTerminalCmdOpts) *Container {
q := r.Query.Select("withDefaultTerminalCmd")
for i := len(opts) - 1; i >= 0; i-- {
// `experimentalPrivilegedNesting` optional argument
if !querybuilder.IsZeroValue(opts[i].ExperimentalPrivilegedNesting) {
q = q.Arg("experimentalPrivilegedNesting", opts[i].ExperimentalPrivilegedNesting)
}
// `insecureRootCapabilities` optional argument
if !querybuilder.IsZeroValue(opts[i].InsecureRootCapabilities) {
q = q.Arg("insecureRootCapabilities", opts[i].InsecureRootCapabilities)
}
}
q = q.Arg("args", args)
return &Container{
Query: q,
}
}
// ContainerWithDirectoryOpts contains options for Container.WithDirectory
type ContainerWithDirectoryOpts struct {
// Patterns to exclude in the written directory (e.g. ["node_modules/**", ".gitignore", ".git/"]).
Exclude []string
// Patterns to include in the written directory (e.g. ["*.go", "go.mod", "go.sum"]).
Include []string
// A user:group to set for the directory and its contents.
//
// The user and group can either be an ID (1000:1000) or a name (foo:bar).
//
// If the group is omitted, it defaults to the same as the user.
Owner string
}
// Retrieves this container plus a directory written at the given path.
func (r *Container) WithDirectory(path string, directory *Directory, opts ...ContainerWithDirectoryOpts) *Container {
assertNotNil("directory", directory)
q := r.Query.Select("withDirectory")
for i := len(opts) - 1; i >= 0; i-- {
// `exclude` optional argument
if !querybuilder.IsZeroValue(opts[i].Exclude) {
q = q.Arg("exclude", opts[i].Exclude)
}
// `include` optional argument
if !querybuilder.IsZeroValue(opts[i].Include) {
q = q.Arg("include", opts[i].Include)
}
// `owner` optional argument
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
}
q = q.Arg("path", path)
q = q.Arg("directory", directory)
return &Container{
Query: q,
}
}
// ContainerWithEntrypointOpts contains options for Container.WithEntrypoint
type ContainerWithEntrypointOpts struct {
// Don't remove the default arguments when setting the entrypoint.
KeepDefaultArgs bool
}
// Retrieves this container but with a different command entrypoint.
func (r *Container) WithEntrypoint(args []string, opts ...ContainerWithEntrypointOpts) *Container {
q := r.Query.Select("withEntrypoint")
for i := len(opts) - 1; i >= 0; i-- {
// `keepDefaultArgs` optional argument
if !querybuilder.IsZeroValue(opts[i].KeepDefaultArgs) {
q = q.Arg("keepDefaultArgs", opts[i].KeepDefaultArgs)
}
}
q = q.Arg("args", args)
return &Container{
Query: q,
}
}
// ContainerWithEnvVariableOpts contains options for Container.WithEnvVariable
type ContainerWithEnvVariableOpts struct {
// Replace `${VAR}` or `$VAR` in the value according to the current environment variables defined in the container (e.g., "/opt/bin:$PATH").
Expand bool
}
// Retrieves this container plus the given environment variable.
func (r *Container) WithEnvVariable(name string, value string, opts ...ContainerWithEnvVariableOpts) *Container {
q := r.Query.Select("withEnvVariable")
for i := len(opts) - 1; i >= 0; i-- {
// `expand` optional argument
if !querybuilder.IsZeroValue(opts[i].Expand) {
q = q.Arg("expand", opts[i].Expand)
}
}
q = q.Arg("name", name)
q = q.Arg("value", value)
return &Container{
Query: q,
}
}
// ContainerWithExecOpts contains options for Container.WithExec
type ContainerWithExecOpts struct {
// If the container has an entrypoint, ignore it for args rather than using it to wrap them.
SkipEntrypoint bool
// Content to write to the command's standard input before closing (e.g., "Hello world").
Stdin string
// Redirect the command's standard output to a file in the container (e.g., "/tmp/stdout").
RedirectStdout string
// Redirect the command's standard error to a file in the container (e.g., "/tmp/stderr").
RedirectStderr string
// Provides Dagger access to the executed command.
//
// Do not use this option unless you trust the command being executed; the command being executed WILL BE GRANTED FULL ACCESS TO YOUR HOST FILESYSTEM.
ExperimentalPrivilegedNesting bool
// Execute the command with all root capabilities. This is similar to running a command with "sudo" or executing "docker run" with the "--privileged" flag. Containerization does not provide any security guarantees when using this option. It should only be used when absolutely necessary and only with trusted commands.
InsecureRootCapabilities bool
}
// Retrieves this container after executing the specified command inside it.
func (r *Container) WithExec(args []string, opts ...ContainerWithExecOpts) *Container {
q := r.Query.Select("withExec")
for i := len(opts) - 1; i >= 0; i-- {
// `skipEntrypoint` optional argument
if !querybuilder.IsZeroValue(opts[i].SkipEntrypoint) {
q = q.Arg("skipEntrypoint", opts[i].SkipEntrypoint)
}
// `stdin` optional argument
if !querybuilder.IsZeroValue(opts[i].Stdin) {
q = q.Arg("stdin", opts[i].Stdin)
}
// `redirectStdout` optional argument
if !querybuilder.IsZeroValue(opts[i].RedirectStdout) {
q = q.Arg("redirectStdout", opts[i].RedirectStdout)
}
// `redirectStderr` optional argument
if !querybuilder.IsZeroValue(opts[i].RedirectStderr) {
q = q.Arg("redirectStderr", opts[i].RedirectStderr)
}
// `experimentalPrivilegedNesting` optional argument
if !querybuilder.IsZeroValue(opts[i].ExperimentalPrivilegedNesting) {
q = q.Arg("experimentalPrivilegedNesting", opts[i].ExperimentalPrivilegedNesting)
}
// `insecureRootCapabilities` optional argument
if !querybuilder.IsZeroValue(opts[i].InsecureRootCapabilities) {
q = q.Arg("insecureRootCapabilities", opts[i].InsecureRootCapabilities)
}
}
q = q.Arg("args", args)
return &Container{
Query: q,
}
}
// ContainerWithExposedPortOpts contains options for Container.WithExposedPort
type ContainerWithExposedPortOpts struct {
// Transport layer network protocol
Protocol NetworkProtocol
// Optional port description
Description string
// Skip the health check when run as a service.
ExperimentalSkipHealthcheck bool
}
// Expose a network port.
//
// Exposed ports serve two purposes:
//
// - For health checks and introspection, when running services
//
// - For setting the EXPOSE OCI field when publishing the container
func (r *Container) WithExposedPort(port int, opts ...ContainerWithExposedPortOpts) *Container {
q := r.Query.Select("withExposedPort")
for i := len(opts) - 1; i >= 0; i-- {
// `protocol` optional argument
if !querybuilder.IsZeroValue(opts[i].Protocol) {
q = q.Arg("protocol", opts[i].Protocol)
}
// `description` optional argument
if !querybuilder.IsZeroValue(opts[i].Description) {
q = q.Arg("description", opts[i].Description)
}
// `experimentalSkipHealthcheck` optional argument
if !querybuilder.IsZeroValue(opts[i].ExperimentalSkipHealthcheck) {
q = q.Arg("experimentalSkipHealthcheck", opts[i].ExperimentalSkipHealthcheck)
}
}
q = q.Arg("port", port)
return &Container{
Query: q,
}
}
// ContainerWithFileOpts contains options for Container.WithFile
type ContainerWithFileOpts struct {
// Permission given to the copied file (e.g., 0600).
Permissions int
// A user:group to set for the file.
//
// The user and group can either be an ID (1000:1000) or a name (foo:bar).
//
// If the group is omitted, it defaults to the same as the user.
Owner string
}
// Retrieves this container plus the contents of the given file copied to the given path.
func (r *Container) WithFile(path string, source *File, opts ...ContainerWithFileOpts) *Container {
assertNotNil("source", source)
q := r.Query.Select("withFile")
for i := len(opts) - 1; i >= 0; i-- {
// `permissions` optional argument
if !querybuilder.IsZeroValue(opts[i].Permissions) {
q = q.Arg("permissions", opts[i].Permissions)
}
// `owner` optional argument
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
}
q = q.Arg("path", path)
q = q.Arg("source", source)
return &Container{
Query: q,
}
}
// ContainerWithFilesOpts contains options for Container.WithFiles
type ContainerWithFilesOpts struct {
// Permission given to the copied files (e.g., 0600).
Permissions int
// A user:group to set for the files.
//
// The user and group can either be an ID (1000:1000) or a name (foo:bar).
//
// If the group is omitted, it defaults to the same as the user.
Owner string
}
// Retrieves this container plus the contents of the given files copied to the given path.
func (r *Container) WithFiles(path string, sources []*File, opts ...ContainerWithFilesOpts) *Container {
q := r.Query.Select("withFiles")
for i := len(opts) - 1; i >= 0; i-- {
// `permissions` optional argument
if !querybuilder.IsZeroValue(opts[i].Permissions) {
q = q.Arg("permissions", opts[i].Permissions)
}
// `owner` optional argument
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
}
q = q.Arg("path", path)
q = q.Arg("sources", sources)
return &Container{
Query: q,
}
}
// Indicate that subsequent operations should be featured more prominently in the UI.
func (r *Container) WithFocus() *Container {
q := r.Query.Select("withFocus")
return &Container{
Query: q,
}
}
// Retrieves this container plus the given label.
func (r *Container) WithLabel(name string, value string) *Container {
q := r.Query.Select("withLabel")
q = q.Arg("name", name)
q = q.Arg("value", value)
return &Container{
Query: q,
}
}
// ContainerWithMountedCacheOpts contains options for Container.WithMountedCache
type ContainerWithMountedCacheOpts struct {
// Identifier of the directory to use as the cache volume's root.
Source *Directory
// Sharing mode of the cache volume.
Sharing CacheSharingMode
// A user:group to set for the mounted cache directory.
//
// Note that this changes the ownership of the specified mount along with the initial filesystem provided by source (if any). It does not have any effect if/when the cache has already been created.
//
// The user and group can either be an ID (1000:1000) or a name (foo:bar).
//
// If the group is omitted, it defaults to the same as the user.
Owner string
}
// Retrieves this container plus a cache volume mounted at the given path.
func (r *Container) WithMountedCache(path string, cache *CacheVolume, opts ...ContainerWithMountedCacheOpts) *Container {
assertNotNil("cache", cache)
q := r.Query.Select("withMountedCache")
for i := len(opts) - 1; i >= 0; i-- {
// `source` optional argument
if !querybuilder.IsZeroValue(opts[i].Source) {
q = q.Arg("source", opts[i].Source)
}
// `sharing` optional argument
if !querybuilder.IsZeroValue(opts[i].Sharing) {
q = q.Arg("sharing", opts[i].Sharing)
}
// `owner` optional argument
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
}
q = q.Arg("path", path)
q = q.Arg("cache", cache)
return &Container{
Query: q,
}
}
// ContainerWithMountedDirectoryOpts contains options for Container.WithMountedDirectory
type ContainerWithMountedDirectoryOpts struct {
// A user:group to set for the mounted directory and its contents.
//
// The user and group can either be an ID (1000:1000) or a name (foo:bar).
//
// If the group is omitted, it defaults to the same as the user.
Owner string
}
// Retrieves this container plus a directory mounted at the given path.
func (r *Container) WithMountedDirectory(path string, source *Directory, opts ...ContainerWithMountedDirectoryOpts) *Container {
assertNotNil("source", source)
q := r.Query.Select("withMountedDirectory")
for i := len(opts) - 1; i >= 0; i-- {
// `owner` optional argument
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
}
q = q.Arg("path", path)
q = q.Arg("source", source)
return &Container{
Query: q,
}
}
// ContainerWithMountedFileOpts contains options for Container.WithMountedFile
type ContainerWithMountedFileOpts struct {
// A user or user:group to set for the mounted file.
//
// The user and group can either be an ID (1000:1000) or a name (foo:bar).
//
// If the group is omitted, it defaults to the same as the user.
Owner string
}
// Retrieves this container plus a file mounted at the given path.
func (r *Container) WithMountedFile(path string, source *File, opts ...ContainerWithMountedFileOpts) *Container {
assertNotNil("source", source)
q := r.Query.Select("withMountedFile")
for i := len(opts) - 1; i >= 0; i-- {
// `owner` optional argument
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
}
q = q.Arg("path", path)
q = q.Arg("source", source)
return &Container{
Query: q,
}
}
// ContainerWithMountedSecretOpts contains options for Container.WithMountedSecret
type ContainerWithMountedSecretOpts struct {
// A user:group to set for the mounted secret.
//
// The user and group can either be an ID (1000:1000) or a name (foo:bar).
//
// If the group is omitted, it defaults to the same as the user.
Owner string
// Permission given to the mounted secret (e.g., 0600).
//
// This option requires an owner to be set to be active.
Mode int
}
// Retrieves this container plus a secret mounted into a file at the given path.
func (r *Container) WithMountedSecret(path string, source *Secret, opts ...ContainerWithMountedSecretOpts) *Container {
assertNotNil("source", source)
q := r.Query.Select("withMountedSecret")
for i := len(opts) - 1; i >= 0; i-- {
// `owner` optional argument
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
// `mode` optional argument
if !querybuilder.IsZeroValue(opts[i].Mode) {
q = q.Arg("mode", opts[i].Mode)
}
}
q = q.Arg("path", path)
q = q.Arg("source", source)
return &Container{
Query: q,
}
}
// Retrieves this container plus a temporary directory mounted at the given path.
func (r *Container) WithMountedTemp(path string) *Container {
q := r.Query.Select("withMountedTemp")
q = q.Arg("path", path)
return &Container{
Query: q,
}
}
// ContainerWithNewFileOpts contains options for Container.WithNewFile
type ContainerWithNewFileOpts struct {
// Content of the file to write (e.g., "Hello world!").
Contents string
// Permission given to the written file (e.g., 0600).
Permissions int
// A user:group to set for the file.
//
// The user and group can either be an ID (1000:1000) or a name (foo:bar).
//
// If the group is omitted, it defaults to the same as the user.
Owner string
}
// Retrieves this container plus a new file written at the given path.
func (r *Container) WithNewFile(path string, opts ...ContainerWithNewFileOpts) *Container {
q := r.Query.Select("withNewFile")
for i := len(opts) - 1; i >= 0; i-- {
// `contents` optional argument
if !querybuilder.IsZeroValue(opts[i].Contents) {
q = q.Arg("contents", opts[i].Contents)
}
// `permissions` optional argument
if !querybuilder.IsZeroValue(opts[i].Permissions) {
q = q.Arg("permissions", opts[i].Permissions)
}
// `owner` optional argument
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
}
q = q.Arg("path", path)
return &Container{
Query: q,
}
}
// Retrieves this container with a registry authentication for a given address.
func (r *Container) WithRegistryAuth(address string, username string, secret *Secret) *Container {
assertNotNil("secret", secret)
q := r.Query.Select("withRegistryAuth")
q = q.Arg("address", address)
q = q.Arg("username", username)
q = q.Arg("secret", secret)
return &Container{
Query: q,
}
}
// Retrieves the container with the given directory mounted to /.
func (r *Container) WithRootfs(directory *Directory) *Container {
assertNotNil("directory", directory)
q := r.Query.Select("withRootfs")
q = q.Arg("directory", directory)
return &Container{
Query: q,
}
}
// Retrieves this container plus an env variable containing the given secret.
func (r *Container) WithSecretVariable(name string, secret *Secret) *Container {
assertNotNil("secret", secret)
q := r.Query.Select("withSecretVariable")
q = q.Arg("name", name)
q = q.Arg("secret", secret)
return &Container{
Query: q,
}
}
// Establish a runtime dependency on a service.
//
// The service will be started automatically when needed and detached when it is no longer needed, executing the default command if none is set.
//
// The service will be reachable from the container via the provided hostname alias.
//
// The service dependency will also convey to any files or directories produced by the container.
func (r *Container) WithServiceBinding(alias string, service *Service) *Container {
assertNotNil("service", service)
q := r.Query.Select("withServiceBinding")
q = q.Arg("alias", alias)
q = q.Arg("service", service)
return &Container{
Query: q,
}
}
// ContainerWithUnixSocketOpts contains options for Container.WithUnixSocket
type ContainerWithUnixSocketOpts struct {
// A user:group to set for the mounted socket.
//
// The user and group can either be an ID (1000:1000) or a name (foo:bar).
//
// If the group is omitted, it defaults to the same as the user.
Owner string
}
// Retrieves this container plus a socket forwarded to the given Unix socket path.
func (r *Container) WithUnixSocket(path string, source *Socket, opts ...ContainerWithUnixSocketOpts) *Container {
assertNotNil("source", source)
q := r.Query.Select("withUnixSocket")
for i := len(opts) - 1; i >= 0; i-- {
// `owner` optional argument
if !querybuilder.IsZeroValue(opts[i].Owner) {
q = q.Arg("owner", opts[i].Owner)
}
}
q = q.Arg("path", path)
q = q.Arg("source", source)
return &Container{
Query: q,
}
}
// Retrieves this container with a different command user.
func (r *Container) WithUser(name string) *Container {
q := r.Query.Select("withUser")
q = q.Arg("name", name)
return &Container{
Query: q,
}
}
// Retrieves this container with a different working directory.
func (r *Container) WithWorkdir(path string) *Container {
q := r.Query.Select("withWorkdir")
q = q.Arg("path", path)
return &Container{
Query: q,
}
}
// Retrieves this container with unset default arguments for future commands.
func (r *Container) WithoutDefaultArgs() *Container {
q := r.Query.Select("withoutDefaultArgs")
return &Container{
Query: q,
}
}
// ContainerWithoutEntrypointOpts contains options for Container.WithoutEntrypoint
type ContainerWithoutEntrypointOpts struct {
// Don't remove the default arguments when unsetting the entrypoint.
KeepDefaultArgs bool
}
// Retrieves this container with an unset command entrypoint.
func (r *Container) WithoutEntrypoint(opts ...ContainerWithoutEntrypointOpts) *Container {
q := r.Query.Select("withoutEntrypoint")
for i := len(opts) - 1; i >= 0; i-- {
// `keepDefaultArgs` optional argument
if !querybuilder.IsZeroValue(opts[i].KeepDefaultArgs) {
q = q.Arg("keepDefaultArgs", opts[i].KeepDefaultArgs)
}
}
return &Container{
Query: q,
}
}
// Retrieves this container minus the given environment variable.
func (r *Container) WithoutEnvVariable(name string) *Container {
q := r.Query.Select("withoutEnvVariable")
q = q.Arg("name", name)
return &Container{
Query: q,
}
}
// ContainerWithoutExposedPortOpts contains options for Container.WithoutExposedPort
type ContainerWithoutExposedPortOpts struct {
// Port protocol to unexpose
Protocol NetworkProtocol
}
// Unexpose a previously exposed port.
func (r *Container) WithoutExposedPort(port int, opts ...ContainerWithoutExposedPortOpts) *Container {
q := r.Query.Select("withoutExposedPort")
for i := len(opts) - 1; i >= 0; i-- {
// `protocol` optional argument
if !querybuilder.IsZeroValue(opts[i].Protocol) {
q = q.Arg("protocol", opts[i].Protocol)
}
}
q = q.Arg("port", port)
return &Container{
Query: q,
}
}
// Indicate that subsequent operations should not be featured more prominently in the UI.
//
// This is the initial state of all containers.
func (r *Container) WithoutFocus() *Container {
q := r.Query.Select("withoutFocus")
return &Container{
Query: q,
}
}
// Retrieves this container minus the given environment label.
func (r *Container) WithoutLabel(name string) *Container {
q := r.Query.Select("withoutLabel")
q = q.Arg("name", name)
return &Container{
Query: q,
}
}
// Retrieves this container after unmounting everything at the given path.
func (r *Container) WithoutMount(path string) *Container {
q := r.Query.Select("withoutMount")
q = q.Arg("path", path)
return &Container{
Query: q,
}
}
// Retrieves this container without the registry authentication of a given address.
func (r *Container) WithoutRegistryAuth(address string) *Container {
q := r.Query.Select("withoutRegistryAuth")
q = q.Arg("address", address)
return &Container{
Query: q,
}
}
// Retrieves this container with a previously added Unix socket removed.
func (r *Container) WithoutUnixSocket(path string) *Container {
q := r.Query.Select("withoutUnixSocket")
q = q.Arg("path", path)
return &Container{
Query: q,
}
}
// Retrieves this container with an unset command user.
//
// Should default to root.
func (r *Container) WithoutUser() *Container {
q := r.Query.Select("withoutUser")
return &Container{
Query: q,
}
}
// Retrieves this container with an unset working directory.
//
// Should default to "/".
func (r *Container) WithoutWorkdir() *Container {
q := r.Query.Select("withoutWorkdir")
return &Container{
Query: q,
}
}
// Retrieves the working directory for all commands.
func (r *Container) Workdir(ctx context.Context) (string, error) {
if r.workdir != nil {
return *r.workdir, nil
}
q := r.Query.Select("workdir")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Reflective module API provided to functions at runtime.
type CurrentModule struct {
Query *querybuilder.Selection
id *CurrentModuleID
name *string
}
// A unique identifier for this CurrentModule.
func (r *CurrentModule) ID(ctx context.Context) (CurrentModuleID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response CurrentModuleID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *CurrentModule) XXX_GraphQLType() string {
return "CurrentModule"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *CurrentModule) XXX_GraphQLIDType() string {
return "CurrentModuleID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *CurrentModule) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *CurrentModule) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The name of the module being executed in
func (r *CurrentModule) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.Query.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The directory containing the module's source code loaded into the engine (plus any generated code that may have been created).
func (r *CurrentModule) Source() *Directory {
q := r.Query.Select("source")
return &Directory{
Query: q,
}
}
// CurrentModuleWorkdirOpts contains options for CurrentModule.Workdir
type CurrentModuleWorkdirOpts struct {
// Exclude artifacts that match the given pattern (e.g., ["node_modules/", ".git*"]).
Exclude []string
// Include only artifacts that match the given pattern (e.g., ["app/", "package.*"]).
Include []string
}
// Load a directory from the module's scratch working directory, including any changes that may have been made to it during module function execution.
func (r *CurrentModule) Workdir(path string, opts ...CurrentModuleWorkdirOpts) *Directory {
q := r.Query.Select("workdir")
for i := len(opts) - 1; i >= 0; i-- {
// `exclude` optional argument
if !querybuilder.IsZeroValue(opts[i].Exclude) {
q = q.Arg("exclude", opts[i].Exclude)
}
// `include` optional argument
if !querybuilder.IsZeroValue(opts[i].Include) {
q = q.Arg("include", opts[i].Include)
}
}
q = q.Arg("path", path)
return &Directory{
Query: q,
}
}
// Load a file from the module's scratch working directory, including any changes that may have been made to it during module function execution.Load a file from the module's scratch working directory, including any changes that may have been made to it during module function execution.
func (r *CurrentModule) WorkdirFile(path string) *File {
q := r.Query.Select("workdirFile")
q = q.Arg("path", path)
return &File{
Query: q,
}
}
// A directory.
type Directory struct {
Query *querybuilder.Selection
export *bool
id *DirectoryID
sync *DirectoryID
}
type WithDirectoryFunc func(r *Directory) *Directory
// With calls the provided function with current Directory.
//
// This is useful for reusability and readability by not breaking the calling chain.
func (r *Directory) With(f WithDirectoryFunc) *Directory {
return f(r)
}
// DirectoryAsModuleOpts contains options for Directory.AsModule
type DirectoryAsModuleOpts struct {
// An optional subpath of the directory which contains the module's configuration file.
//
// This is needed when the module code is in a subdirectory but requires parent directories to be loaded in order to execute. For example, the module source code may need a go.mod, project.toml, package.json, etc. file from a parent directory.
//
// If not set, the module source code is loaded from the root of the directory.
SourceRootPath string
}
// Load the directory as a Dagger module
func (r *Directory) AsModule(opts ...DirectoryAsModuleOpts) *Module {
q := r.Query.Select("asModule")
for i := len(opts) - 1; i >= 0; i-- {
// `sourceRootPath` optional argument
if !querybuilder.IsZeroValue(opts[i].SourceRootPath) {
q = q.Arg("sourceRootPath", opts[i].SourceRootPath)
}
}
return &Module{
Query: q,
}
}
// Gets the difference between this directory and an another directory.
func (r *Directory) Diff(other *Directory) *Directory {
assertNotNil("other", other)
q := r.Query.Select("diff")
q = q.Arg("other", other)
return &Directory{
Query: q,
}
}
// Retrieves a directory at the given path.
func (r *Directory) Directory(path string) *Directory {
q := r.Query.Select("directory")
q = q.Arg("path", path)
return &Directory{
Query: q,
}
}
// DirectoryDockerBuildOpts contains options for Directory.DockerBuild
type DirectoryDockerBuildOpts struct {
// The platform to build.
Platform Platform
// Path to the Dockerfile to use (e.g., "frontend.Dockerfile").
Dockerfile string
// Target build stage to build.
Target string
// Build arguments to use in the build.
BuildArgs []BuildArg
// Secrets to pass to the build.
//
// They will be mounted at /run/secrets/[secret-name].
Secrets []*Secret
}
// Builds a new Docker container from this directory.
func (r *Directory) DockerBuild(opts ...DirectoryDockerBuildOpts) *Container {
q := r.Query.Select("dockerBuild")
for i := len(opts) - 1; i >= 0; i-- {
// `platform` optional argument
if !querybuilder.IsZeroValue(opts[i].Platform) {
q = q.Arg("platform", opts[i].Platform)
}
// `dockerfile` optional argument
if !querybuilder.IsZeroValue(opts[i].Dockerfile) {
q = q.Arg("dockerfile", opts[i].Dockerfile)
}
// `target` optional argument
if !querybuilder.IsZeroValue(opts[i].Target) {
q = q.Arg("target", opts[i].Target)
}
// `buildArgs` optional argument
if !querybuilder.IsZeroValue(opts[i].BuildArgs) {
q = q.Arg("buildArgs", opts[i].BuildArgs)
}
// `secrets` optional argument
if !querybuilder.IsZeroValue(opts[i].Secrets) {
q = q.Arg("secrets", opts[i].Secrets)
}
}
return &Container{
Query: q,
}
}
// DirectoryEntriesOpts contains options for Directory.Entries
type DirectoryEntriesOpts struct {
// Location of the directory to look at (e.g., "/src").
Path string
}
// Returns a list of files and directories at the given path.
func (r *Directory) Entries(ctx context.Context, opts ...DirectoryEntriesOpts) ([]string, error) {
q := r.Query.Select("entries")
for i := len(opts) - 1; i >= 0; i-- {
// `path` optional argument
if !querybuilder.IsZeroValue(opts[i].Path) {
q = q.Arg("path", opts[i].Path)
}
}
var response []string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Writes the contents of the directory to a path on the host.
func (r *Directory) Export(ctx context.Context, path string) (bool, error) {
if r.export != nil {
return *r.export, nil
}
q := r.Query.Select("export")
q = q.Arg("path", path)
var response bool
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Retrieves a file at the given path.
func (r *Directory) File(path string) *File {
q := r.Query.Select("file")
q = q.Arg("path", path)
return &File{
Query: q,
}
}
// Returns a list of files and directories that matche the given pattern.
func (r *Directory) Glob(ctx context.Context, pattern string) ([]string, error) {
q := r.Query.Select("glob")
q = q.Arg("pattern", pattern)
var response []string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A unique identifier for this Directory.
func (r *Directory) ID(ctx context.Context) (DirectoryID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response DirectoryID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *Directory) XXX_GraphQLType() string {
return "Directory"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *Directory) XXX_GraphQLIDType() string {
return "DirectoryID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *Directory) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Directory) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// DirectoryPipelineOpts contains options for Directory.Pipeline
type DirectoryPipelineOpts struct {
// Description of the sub-pipeline.
Description string
// Labels to apply to the sub-pipeline.
Labels []PipelineLabel
}
// Creates a named sub-pipeline.
func (r *Directory) Pipeline(name string, opts ...DirectoryPipelineOpts) *Directory {
q := r.Query.Select("pipeline")
for i := len(opts) - 1; i >= 0; i-- {
// `description` optional argument
if !querybuilder.IsZeroValue(opts[i].Description) {
q = q.Arg("description", opts[i].Description)
}
// `labels` optional argument
if !querybuilder.IsZeroValue(opts[i].Labels) {
q = q.Arg("labels", opts[i].Labels)
}
}
q = q.Arg("name", name)
return &Directory{
Query: q,
}
}
// Force evaluation in the engine.
func (r *Directory) Sync(ctx context.Context) (*Directory, error) {
q := r.Query.Select("sync")
return r, q.Execute(ctx)
}
// DirectoryWithDirectoryOpts contains options for Directory.WithDirectory
type DirectoryWithDirectoryOpts struct {
// Exclude artifacts that match the given pattern (e.g., ["node_modules/", ".git*"]).
Exclude []string
// Include only artifacts that match the given pattern (e.g., ["app/", "package.*"]).
Include []string
}
// Retrieves this directory plus a directory written at the given path.
func (r *Directory) WithDirectory(path string, directory *Directory, opts ...DirectoryWithDirectoryOpts) *Directory {
assertNotNil("directory", directory)
q := r.Query.Select("withDirectory")
for i := len(opts) - 1; i >= 0; i-- {
// `exclude` optional argument
if !querybuilder.IsZeroValue(opts[i].Exclude) {
q = q.Arg("exclude", opts[i].Exclude)
}
// `include` optional argument
if !querybuilder.IsZeroValue(opts[i].Include) {
q = q.Arg("include", opts[i].Include)
}
}
q = q.Arg("path", path)
q = q.Arg("directory", directory)
return &Directory{
Query: q,
}
}
// DirectoryWithFileOpts contains options for Directory.WithFile
type DirectoryWithFileOpts struct {
// Permission given to the copied file (e.g., 0600).
Permissions int
}
// Retrieves this directory plus the contents of the given file copied to the given path.
func (r *Directory) WithFile(path string, source *File, opts ...DirectoryWithFileOpts) *Directory {
assertNotNil("source", source)
q := r.Query.Select("withFile")
for i := len(opts) - 1; i >= 0; i-- {
// `permissions` optional argument
if !querybuilder.IsZeroValue(opts[i].Permissions) {
q = q.Arg("permissions", opts[i].Permissions)
}
}
q = q.Arg("path", path)
q = q.Arg("source", source)
return &Directory{
Query: q,
}
}
// DirectoryWithFilesOpts contains options for Directory.WithFiles
type DirectoryWithFilesOpts struct {
// Permission given to the copied files (e.g., 0600).
Permissions int
}
// Retrieves this directory plus the contents of the given files copied to the given path.
func (r *Directory) WithFiles(path string, sources []*File, opts ...DirectoryWithFilesOpts) *Directory {
q := r.Query.Select("withFiles")
for i := len(opts) - 1; i >= 0; i-- {
// `permissions` optional argument
if !querybuilder.IsZeroValue(opts[i].Permissions) {
q = q.Arg("permissions", opts[i].Permissions)
}
}
q = q.Arg("path", path)
q = q.Arg("sources", sources)
return &Directory{
Query: q,
}
}
// DirectoryWithNewDirectoryOpts contains options for Directory.WithNewDirectory
type DirectoryWithNewDirectoryOpts struct {
// Permission granted to the created directory (e.g., 0777).
Permissions int
}
// Retrieves this directory plus a new directory created at the given path.
func (r *Directory) WithNewDirectory(path string, opts ...DirectoryWithNewDirectoryOpts) *Directory {
q := r.Query.Select("withNewDirectory")
for i := len(opts) - 1; i >= 0; i-- {
// `permissions` optional argument
if !querybuilder.IsZeroValue(opts[i].Permissions) {
q = q.Arg("permissions", opts[i].Permissions)
}
}
q = q.Arg("path", path)
return &Directory{
Query: q,
}
}
// DirectoryWithNewFileOpts contains options for Directory.WithNewFile
type DirectoryWithNewFileOpts struct {
// Permission given to the copied file (e.g., 0600).
Permissions int
}
// Retrieves this directory plus a new file written at the given path.
func (r *Directory) WithNewFile(path string, contents string, opts ...DirectoryWithNewFileOpts) *Directory {
q := r.Query.Select("withNewFile")
for i := len(opts) - 1; i >= 0; i-- {
// `permissions` optional argument
if !querybuilder.IsZeroValue(opts[i].Permissions) {
q = q.Arg("permissions", opts[i].Permissions)
}
}
q = q.Arg("path", path)
q = q.Arg("contents", contents)
return &Directory{
Query: q,
}
}
// Retrieves this directory with all file/dir timestamps set to the given time.
func (r *Directory) WithTimestamps(timestamp int) *Directory {
q := r.Query.Select("withTimestamps")
q = q.Arg("timestamp", timestamp)
return &Directory{
Query: q,
}
}
// Retrieves this directory with the directory at the given path removed.
func (r *Directory) WithoutDirectory(path string) *Directory {
q := r.Query.Select("withoutDirectory")
q = q.Arg("path", path)
return &Directory{
Query: q,
}
}
// Retrieves this directory with the file at the given path removed.
func (r *Directory) WithoutFile(path string) *Directory {
q := r.Query.Select("withoutFile")
q = q.Arg("path", path)
return &Directory{
Query: q,
}
}
// An environment variable name and value.
type EnvVariable struct {
Query *querybuilder.Selection
id *EnvVariableID
name *string
value *string
}
// A unique identifier for this EnvVariable.
func (r *EnvVariable) ID(ctx context.Context) (EnvVariableID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response EnvVariableID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *EnvVariable) XXX_GraphQLType() string {
return "EnvVariable"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *EnvVariable) XXX_GraphQLIDType() string {
return "EnvVariableID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *EnvVariable) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *EnvVariable) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The environment variable name.
func (r *EnvVariable) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.Query.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The environment variable value.
func (r *EnvVariable) Value(ctx context.Context) (string, error) {
if r.value != nil {
return *r.value, nil
}
q := r.Query.Select("value")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A definition of a field on a custom object defined in a Module.
//
// A field on an object has a static value, as opposed to a function on an object whose value is computed by invoking code (and can accept arguments).
type FieldTypeDef struct {
Query *querybuilder.Selection
description *string
id *FieldTypeDefID
name *string
}
// A doc string for the field, if any.
func (r *FieldTypeDef) Description(ctx context.Context) (string, error) {
if r.description != nil {
return *r.description, nil
}
q := r.Query.Select("description")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A unique identifier for this FieldTypeDef.
func (r *FieldTypeDef) ID(ctx context.Context) (FieldTypeDefID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response FieldTypeDefID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *FieldTypeDef) XXX_GraphQLType() string {
return "FieldTypeDef"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *FieldTypeDef) XXX_GraphQLIDType() string {
return "FieldTypeDefID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *FieldTypeDef) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *FieldTypeDef) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The name of the field in lowerCamelCase format.
func (r *FieldTypeDef) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.Query.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The type of the field.
func (r *FieldTypeDef) TypeDef() *TypeDef {
q := r.Query.Select("typeDef")
return &TypeDef{
Query: q,
}
}
// A file.
type File struct {
Query *querybuilder.Selection
contents *string
export *bool
id *FileID
name *string
size *int
sync *FileID
}
type WithFileFunc func(r *File) *File
// With calls the provided function with current File.
//
// This is useful for reusability and readability by not breaking the calling chain.
func (r *File) With(f WithFileFunc) *File {
return f(r)
}
// Retrieves the contents of the file.
func (r *File) Contents(ctx context.Context) (string, error) {
if r.contents != nil {
return *r.contents, nil
}
q := r.Query.Select("contents")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// FileExportOpts contains options for File.Export
type FileExportOpts struct {
// If allowParentDirPath is true, the path argument can be a directory path, in which case the file will be created in that directory.
AllowParentDirPath bool
}
// Writes the file to a file path on the host.
func (r *File) Export(ctx context.Context, path string, opts ...FileExportOpts) (bool, error) {
if r.export != nil {
return *r.export, nil
}
q := r.Query.Select("export")
for i := len(opts) - 1; i >= 0; i-- {
// `allowParentDirPath` optional argument
if !querybuilder.IsZeroValue(opts[i].AllowParentDirPath) {
q = q.Arg("allowParentDirPath", opts[i].AllowParentDirPath)
}
}
q = q.Arg("path", path)
var response bool
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A unique identifier for this File.
func (r *File) ID(ctx context.Context) (FileID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response FileID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *File) XXX_GraphQLType() string {
return "File"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *File) XXX_GraphQLIDType() string {
return "FileID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *File) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *File) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// Retrieves the name of the file.
func (r *File) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.Query.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Retrieves the size of the file, in bytes.
func (r *File) Size(ctx context.Context) (int, error) {
if r.size != nil {
return *r.size, nil
}
q := r.Query.Select("size")
var response int
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Force evaluation in the engine.
func (r *File) Sync(ctx context.Context) (*File, error) {
q := r.Query.Select("sync")
return r, q.Execute(ctx)
}
// Retrieves this file with its created/modified timestamps set to the given time.
func (r *File) WithTimestamps(timestamp int) *File {
q := r.Query.Select("withTimestamps")
q = q.Arg("timestamp", timestamp)
return &File{
Query: q,
}
}
// Function represents a resolver provided by a Module.
//
// A function always evaluates against a parent object and is given a set of named arguments.
type Function struct {
Query *querybuilder.Selection
description *string
id *FunctionID
name *string
}
type WithFunctionFunc func(r *Function) *Function
// With calls the provided function with current Function.
//
// This is useful for reusability and readability by not breaking the calling chain.
func (r *Function) With(f WithFunctionFunc) *Function {
return f(r)
}
// Arguments accepted by the function, if any.
func (r *Function) Args(ctx context.Context) ([]FunctionArg, error) {
q := r.Query.Select("args")
q = q.Select("id")
type args struct {
Id FunctionArgID
}
convert := func(fields []args) []FunctionArg {
out := []FunctionArg{}
for i := range fields {
val := FunctionArg{id: &fields[i].Id}
val.Query = q.Root().Select("loadFunctionArgFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []args
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// A doc string for the function, if any.
func (r *Function) Description(ctx context.Context) (string, error) {
if r.description != nil {
return *r.description, nil
}
q := r.Query.Select("description")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A unique identifier for this Function.
func (r *Function) ID(ctx context.Context) (FunctionID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response FunctionID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *Function) XXX_GraphQLType() string {
return "Function"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *Function) XXX_GraphQLIDType() string {
return "FunctionID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *Function) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Function) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The name of the function.
func (r *Function) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.Query.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The type returned by the function.
func (r *Function) ReturnType() *TypeDef {
q := r.Query.Select("returnType")
return &TypeDef{
Query: q,
}
}
// FunctionWithArgOpts contains options for Function.WithArg
type FunctionWithArgOpts struct {
// A doc string for the argument, if any
Description string
// A default value to use for this argument if not explicitly set by the caller, if any
DefaultValue JSON
}
// Returns the function with the provided argument
func (r *Function) WithArg(name string, typeDef *TypeDef, opts ...FunctionWithArgOpts) *Function {
assertNotNil("typeDef", typeDef)
q := r.Query.Select("withArg")
for i := len(opts) - 1; i >= 0; i-- {
// `description` optional argument
if !querybuilder.IsZeroValue(opts[i].Description) {
q = q.Arg("description", opts[i].Description)
}
// `defaultValue` optional argument
if !querybuilder.IsZeroValue(opts[i].DefaultValue) {
q = q.Arg("defaultValue", opts[i].DefaultValue)
}
}
q = q.Arg("name", name)
q = q.Arg("typeDef", typeDef)
return &Function{
Query: q,
}
}
// Returns the function with the given doc string.
func (r *Function) WithDescription(description string) *Function {
q := r.Query.Select("withDescription")
q = q.Arg("description", description)
return &Function{
Query: q,
}
}
// An argument accepted by a function.
//
// This is a specification for an argument at function definition time, not an argument passed at function call time.
type FunctionArg struct {
Query *querybuilder.Selection
defaultValue *JSON
description *string
id *FunctionArgID
name *string
}
// A default value to use for this argument when not explicitly set by the caller, if any.
func (r *FunctionArg) DefaultValue(ctx context.Context) (JSON, error) {
if r.defaultValue != nil {
return *r.defaultValue, nil
}
q := r.Query.Select("defaultValue")
var response JSON
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A doc string for the argument, if any.
func (r *FunctionArg) Description(ctx context.Context) (string, error) {
if r.description != nil {
return *r.description, nil
}
q := r.Query.Select("description")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A unique identifier for this FunctionArg.
func (r *FunctionArg) ID(ctx context.Context) (FunctionArgID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response FunctionArgID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *FunctionArg) XXX_GraphQLType() string {
return "FunctionArg"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *FunctionArg) XXX_GraphQLIDType() string {
return "FunctionArgID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *FunctionArg) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *FunctionArg) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The name of the argument in lowerCamelCase format.
func (r *FunctionArg) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.Query.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The type of the argument.
func (r *FunctionArg) TypeDef() *TypeDef {
q := r.Query.Select("typeDef")
return &TypeDef{
Query: q,
}
}
// An active function call.
type FunctionCall struct {
Query *querybuilder.Selection
id *FunctionCallID
name *string
parent *JSON
parentName *string
returnValue *Void
}
// A unique identifier for this FunctionCall.
func (r *FunctionCall) ID(ctx context.Context) (FunctionCallID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response FunctionCallID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *FunctionCall) XXX_GraphQLType() string {
return "FunctionCall"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *FunctionCall) XXX_GraphQLIDType() string {
return "FunctionCallID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *FunctionCall) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *FunctionCall) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The argument values the function is being invoked with.
func (r *FunctionCall) InputArgs(ctx context.Context) ([]FunctionCallArgValue, error) {
q := r.Query.Select("inputArgs")
q = q.Select("id")
type inputArgs struct {
Id FunctionCallArgValueID
}
convert := func(fields []inputArgs) []FunctionCallArgValue {
out := []FunctionCallArgValue{}
for i := range fields {
val := FunctionCallArgValue{id: &fields[i].Id}
val.Query = q.Root().Select("loadFunctionCallArgValueFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []inputArgs
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// The name of the function being called.
func (r *FunctionCall) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.Query.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The value of the parent object of the function being called. If the function is top-level to the module, this is always an empty object.
func (r *FunctionCall) Parent(ctx context.Context) (JSON, error) {
if r.parent != nil {
return *r.parent, nil
}
q := r.Query.Select("parent")
var response JSON
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The name of the parent object of the function being called. If the function is top-level to the module, this is the name of the module.
func (r *FunctionCall) ParentName(ctx context.Context) (string, error) {
if r.parentName != nil {
return *r.parentName, nil
}
q := r.Query.Select("parentName")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Set the return value of the function call to the provided value.
func (r *FunctionCall) ReturnValue(ctx context.Context, value JSON) (Void, error) {
if r.returnValue != nil {
return *r.returnValue, nil
}
q := r.Query.Select("returnValue")
q = q.Arg("value", value)
var response Void
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A value passed as a named argument to a function call.
type FunctionCallArgValue struct {
Query *querybuilder.Selection
id *FunctionCallArgValueID
name *string
value *JSON
}
// A unique identifier for this FunctionCallArgValue.
func (r *FunctionCallArgValue) ID(ctx context.Context) (FunctionCallArgValueID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response FunctionCallArgValueID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *FunctionCallArgValue) XXX_GraphQLType() string {
return "FunctionCallArgValue"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *FunctionCallArgValue) XXX_GraphQLIDType() string {
return "FunctionCallArgValueID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *FunctionCallArgValue) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *FunctionCallArgValue) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The name of the argument.
func (r *FunctionCallArgValue) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.Query.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The value of the argument represented as a JSON serialized string.
func (r *FunctionCallArgValue) Value(ctx context.Context) (JSON, error) {
if r.value != nil {
return *r.value, nil
}
q := r.Query.Select("value")
var response JSON
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The result of running an SDK's codegen.
type GeneratedCode struct {
Query *querybuilder.Selection
id *GeneratedCodeID
}
type WithGeneratedCodeFunc func(r *GeneratedCode) *GeneratedCode
// With calls the provided function with current GeneratedCode.
//
// This is useful for reusability and readability by not breaking the calling chain.
func (r *GeneratedCode) With(f WithGeneratedCodeFunc) *GeneratedCode {
return f(r)
}
// The directory containing the generated code.
func (r *GeneratedCode) Code() *Directory {
q := r.Query.Select("code")
return &Directory{
Query: q,
}
}
// A unique identifier for this GeneratedCode.
func (r *GeneratedCode) ID(ctx context.Context) (GeneratedCodeID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response GeneratedCodeID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *GeneratedCode) XXX_GraphQLType() string {
return "GeneratedCode"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *GeneratedCode) XXX_GraphQLIDType() string {
return "GeneratedCodeID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *GeneratedCode) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *GeneratedCode) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// List of paths to mark generated in version control (i.e. .gitattributes).
func (r *GeneratedCode) VcsGeneratedPaths(ctx context.Context) ([]string, error) {
q := r.Query.Select("vcsGeneratedPaths")
var response []string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// List of paths to ignore in version control (i.e. .gitignore).
func (r *GeneratedCode) VcsIgnoredPaths(ctx context.Context) ([]string, error) {
q := r.Query.Select("vcsIgnoredPaths")
var response []string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Set the list of paths to mark generated in version control.
func (r *GeneratedCode) WithVCSGeneratedPaths(paths []string) *GeneratedCode {
q := r.Query.Select("withVCSGeneratedPaths")
q = q.Arg("paths", paths)
return &GeneratedCode{
Query: q,
}
}
// Set the list of paths to ignore in version control.
func (r *GeneratedCode) WithVCSIgnoredPaths(paths []string) *GeneratedCode {
q := r.Query.Select("withVCSIgnoredPaths")
q = q.Arg("paths", paths)
return &GeneratedCode{
Query: q,
}
}
// Module source originating from a git repo.
type GitModuleSource struct {
Query *querybuilder.Selection
cloneURL *string
commit *string
htmlURL *string
id *GitModuleSourceID
rootSubpath *string
version *string
}
// The URL from which the source's git repo can be cloned.
func (r *GitModuleSource) CloneURL(ctx context.Context) (string, error) {
if r.cloneURL != nil {
return *r.cloneURL, nil
}
q := r.Query.Select("cloneURL")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The resolved commit of the git repo this source points to.
func (r *GitModuleSource) Commit(ctx context.Context) (string, error) {
if r.commit != nil {
return *r.commit, nil
}
q := r.Query.Select("commit")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The directory containing everything needed to load load and use the module.
func (r *GitModuleSource) ContextDirectory() *Directory {
q := r.Query.Select("contextDirectory")
return &Directory{
Query: q,
}
}
// The URL to the source's git repo in a web browser
func (r *GitModuleSource) HTMLURL(ctx context.Context) (string, error) {
if r.htmlURL != nil {
return *r.htmlURL, nil
}
q := r.Query.Select("htmlURL")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A unique identifier for this GitModuleSource.
func (r *GitModuleSource) ID(ctx context.Context) (GitModuleSourceID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response GitModuleSourceID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *GitModuleSource) XXX_GraphQLType() string {
return "GitModuleSource"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *GitModuleSource) XXX_GraphQLIDType() string {
return "GitModuleSourceID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *GitModuleSource) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *GitModuleSource) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The path to the root of the module source under the context directory. This directory contains its configuration file. It also contains its source code (possibly as a subdirectory).
func (r *GitModuleSource) RootSubpath(ctx context.Context) (string, error) {
if r.rootSubpath != nil {
return *r.rootSubpath, nil
}
q := r.Query.Select("rootSubpath")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The specified version of the git repo this source points to.
func (r *GitModuleSource) Version(ctx context.Context) (string, error) {
if r.version != nil {
return *r.version, nil
}
q := r.Query.Select("version")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A git ref (tag, branch, or commit).
type GitRef struct {
Query *querybuilder.Selection
commit *string
id *GitRefID
}
// The resolved commit id at this ref.
func (r *GitRef) Commit(ctx context.Context) (string, error) {
if r.commit != nil {
return *r.commit, nil
}
q := r.Query.Select("commit")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A unique identifier for this GitRef.
func (r *GitRef) ID(ctx context.Context) (GitRefID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response GitRefID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *GitRef) XXX_GraphQLType() string {
return "GitRef"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *GitRef) XXX_GraphQLIDType() string {
return "GitRefID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *GitRef) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *GitRef) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// GitRefTreeOpts contains options for GitRef.Tree
type GitRefTreeOpts struct {
// DEPRECATED: This option should be passed to `git` instead.
SSHKnownHosts string
// DEPRECATED: This option should be passed to `git` instead.
SSHAuthSocket *Socket
}
// The filesystem tree at this ref.
func (r *GitRef) Tree(opts ...GitRefTreeOpts) *Directory {
q := r.Query.Select("tree")
for i := len(opts) - 1; i >= 0; i-- {
// `sshKnownHosts` optional argument
if !querybuilder.IsZeroValue(opts[i].SSHKnownHosts) {
q = q.Arg("sshKnownHosts", opts[i].SSHKnownHosts)
}
// `sshAuthSocket` optional argument
if !querybuilder.IsZeroValue(opts[i].SSHAuthSocket) {
q = q.Arg("sshAuthSocket", opts[i].SSHAuthSocket)
}
}
return &Directory{
Query: q,
}
}
// A git repository.
type GitRepository struct {
Query *querybuilder.Selection
id *GitRepositoryID
}
// Returns details of a branch.
func (r *GitRepository) Branch(name string) *GitRef {
q := r.Query.Select("branch")
q = q.Arg("name", name)
return &GitRef{
Query: q,
}
}
// Returns details of a commit.
func (r *GitRepository) Commit(id string) *GitRef {
q := r.Query.Select("commit")
q = q.Arg("id", id)
return &GitRef{
Query: q,
}
}
// A unique identifier for this GitRepository.
func (r *GitRepository) ID(ctx context.Context) (GitRepositoryID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response GitRepositoryID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *GitRepository) XXX_GraphQLType() string {
return "GitRepository"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *GitRepository) XXX_GraphQLIDType() string {
return "GitRepositoryID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *GitRepository) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *GitRepository) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// Returns details of a ref.
func (r *GitRepository) Ref(name string) *GitRef {
q := r.Query.Select("ref")
q = q.Arg("name", name)
return &GitRef{
Query: q,
}
}
// Returns details of a tag.
func (r *GitRepository) Tag(name string) *GitRef {
q := r.Query.Select("tag")
q = q.Arg("name", name)
return &GitRef{
Query: q,
}
}
// Information about the host environment.
type Host struct {
Query *querybuilder.Selection
id *HostID
}
// HostDirectoryOpts contains options for Host.Directory
type HostDirectoryOpts struct {
// Exclude artifacts that match the given pattern (e.g., ["node_modules/", ".git*"]).
Exclude []string
// Include only artifacts that match the given pattern (e.g., ["app/", "package.*"]).
Include []string
}
// Accesses a directory on the host.
func (r *Host) Directory(path string, opts ...HostDirectoryOpts) *Directory {
q := r.Query.Select("directory")
for i := len(opts) - 1; i >= 0; i-- {
// `exclude` optional argument
if !querybuilder.IsZeroValue(opts[i].Exclude) {
q = q.Arg("exclude", opts[i].Exclude)
}
// `include` optional argument
if !querybuilder.IsZeroValue(opts[i].Include) {
q = q.Arg("include", opts[i].Include)
}
}
q = q.Arg("path", path)
return &Directory{
Query: q,
}
}
// Accesses a file on the host.
func (r *Host) File(path string) *File {
q := r.Query.Select("file")
q = q.Arg("path", path)
return &File{
Query: q,
}
}
// A unique identifier for this Host.
func (r *Host) ID(ctx context.Context) (HostID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response HostID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *Host) XXX_GraphQLType() string {
return "Host"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *Host) XXX_GraphQLIDType() string {
return "HostID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *Host) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Host) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// HostServiceOpts contains options for Host.Service
type HostServiceOpts struct {
// Upstream host to forward traffic to.
Host string
}
// Creates a service that forwards traffic to a specified address via the host.
func (r *Host) Service(ports []PortForward, opts ...HostServiceOpts) *Service {
q := r.Query.Select("service")
for i := len(opts) - 1; i >= 0; i-- {
// `host` optional argument
if !querybuilder.IsZeroValue(opts[i].Host) {
q = q.Arg("host", opts[i].Host)
}
}
q = q.Arg("ports", ports)
return &Service{
Query: q,
}
}
// Sets a secret given a user-defined name and the file path on the host, and returns the secret.
//
// The file is limited to a size of 512000 bytes.
func (r *Host) SetSecretFile(name string, path string) *Secret {
q := r.Query.Select("setSecretFile")
q = q.Arg("name", name)
q = q.Arg("path", path)
return &Secret{
Query: q,
}
}
// HostTunnelOpts contains options for Host.Tunnel
type HostTunnelOpts struct {
// Configure explicit port forwarding rules for the tunnel.
//
// If a port's frontend is unspecified or 0, a random port will be chosen by the host.
//
// If no ports are given, all of the service's ports are forwarded. If native is true, each port maps to the same port on the host. If native is false, each port maps to a random port chosen by the host.
//
// If ports are given and native is true, the ports are additive.
Ports []PortForward
// Map each service port to the same port on the host, as if the service were running natively.
//
// Note: enabling may result in port conflicts.
Native bool
}
// Creates a tunnel that forwards traffic from the host to a service.
func (r *Host) Tunnel(service *Service, opts ...HostTunnelOpts) *Service {
assertNotNil("service", service)
q := r.Query.Select("tunnel")
for i := len(opts) - 1; i >= 0; i-- {
// `ports` optional argument
if !querybuilder.IsZeroValue(opts[i].Ports) {
q = q.Arg("ports", opts[i].Ports)
}
// `native` optional argument
if !querybuilder.IsZeroValue(opts[i].Native) {
q = q.Arg("native", opts[i].Native)
}
}
q = q.Arg("service", service)
return &Service{
Query: q,
}
}
// Accesses a Unix socket on the host.
func (r *Host) UnixSocket(path string) *Socket {
q := r.Query.Select("unixSocket")
q = q.Arg("path", path)
return &Socket{
Query: q,
}
}
// A graphql input type, which is essentially just a group of named args.
// This is currently only used to represent pre-existing usage of graphql input types
// in the core API. It is not used by user modules and shouldn't ever be as user
// module accept input objects via their id rather than graphql input types.
type InputTypeDef struct {
Query *querybuilder.Selection
id *InputTypeDefID
name *string
}
// Static fields defined on this input object, if any.
func (r *InputTypeDef) Fields(ctx context.Context) ([]FieldTypeDef, error) {
q := r.Query.Select("fields")
q = q.Select("id")
type fields struct {
Id FieldTypeDefID
}
convert := func(fields []fields) []FieldTypeDef {
out := []FieldTypeDef{}
for i := range fields {
val := FieldTypeDef{id: &fields[i].Id}
val.Query = q.Root().Select("loadFieldTypeDefFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []fields
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// A unique identifier for this InputTypeDef.
func (r *InputTypeDef) ID(ctx context.Context) (InputTypeDefID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response InputTypeDefID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *InputTypeDef) XXX_GraphQLType() string {
return "InputTypeDef"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *InputTypeDef) XXX_GraphQLIDType() string {
return "InputTypeDefID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *InputTypeDef) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *InputTypeDef) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The name of the input object.
func (r *InputTypeDef) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.Query.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A definition of a custom interface defined in a Module.
type InterfaceTypeDef struct {
Query *querybuilder.Selection
description *string
id *InterfaceTypeDefID
name *string
sourceModuleName *string
}
// The doc string for the interface, if any.
func (r *InterfaceTypeDef) Description(ctx context.Context) (string, error) {
if r.description != nil {
return *r.description, nil
}
q := r.Query.Select("description")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Functions defined on this interface, if any.
func (r *InterfaceTypeDef) Functions(ctx context.Context) ([]Function, error) {
q := r.Query.Select("functions")
q = q.Select("id")
type functions struct {
Id FunctionID
}
convert := func(fields []functions) []Function {
out := []Function{}
for i := range fields {
val := Function{id: &fields[i].Id}
val.Query = q.Root().Select("loadFunctionFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []functions
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// A unique identifier for this InterfaceTypeDef.
func (r *InterfaceTypeDef) ID(ctx context.Context) (InterfaceTypeDefID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response InterfaceTypeDefID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *InterfaceTypeDef) XXX_GraphQLType() string {
return "InterfaceTypeDef"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *InterfaceTypeDef) XXX_GraphQLIDType() string {
return "InterfaceTypeDefID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *InterfaceTypeDef) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *InterfaceTypeDef) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The name of the interface.
func (r *InterfaceTypeDef) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.Query.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// If this InterfaceTypeDef is associated with a Module, the name of the module. Unset otherwise.
func (r *InterfaceTypeDef) SourceModuleName(ctx context.Context) (string, error) {
if r.sourceModuleName != nil {
return *r.sourceModuleName, nil
}
q := r.Query.Select("sourceModuleName")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A simple key value object that represents a label.
type Label struct {
Query *querybuilder.Selection
id *LabelID
name *string
value *string
}
// A unique identifier for this Label.
func (r *Label) ID(ctx context.Context) (LabelID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response LabelID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *Label) XXX_GraphQLType() string {
return "Label"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *Label) XXX_GraphQLIDType() string {
return "LabelID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *Label) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Label) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The label name.
func (r *Label) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.Query.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The label value.
func (r *Label) Value(ctx context.Context) (string, error) {
if r.value != nil {
return *r.value, nil
}
q := r.Query.Select("value")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A definition of a list type in a Module.
type ListTypeDef struct {
Query *querybuilder.Selection
id *ListTypeDefID
}
// The type of the elements in the list.
func (r *ListTypeDef) ElementTypeDef() *TypeDef {
q := r.Query.Select("elementTypeDef")
return &TypeDef{
Query: q,
}
}
// A unique identifier for this ListTypeDef.
func (r *ListTypeDef) ID(ctx context.Context) (ListTypeDefID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response ListTypeDefID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *ListTypeDef) XXX_GraphQLType() string {
return "ListTypeDef"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *ListTypeDef) XXX_GraphQLIDType() string {
return "ListTypeDefID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *ListTypeDef) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *ListTypeDef) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// Module source that that originates from a path locally relative to an arbitrary directory.
type LocalModuleSource struct {
Query *querybuilder.Selection
id *LocalModuleSourceID
rootSubpath *string
}
// The directory containing everything needed to load load and use the module.
func (r *LocalModuleSource) ContextDirectory() *Directory {
q := r.Query.Select("contextDirectory")
return &Directory{
Query: q,
}
}
// A unique identifier for this LocalModuleSource.
func (r *LocalModuleSource) ID(ctx context.Context) (LocalModuleSourceID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response LocalModuleSourceID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *LocalModuleSource) XXX_GraphQLType() string {
return "LocalModuleSource"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *LocalModuleSource) XXX_GraphQLIDType() string {
return "LocalModuleSourceID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *LocalModuleSource) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *LocalModuleSource) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The path to the root of the module source under the context directory. This directory contains its configuration file. It also contains its source code (possibly as a subdirectory).
func (r *LocalModuleSource) RootSubpath(ctx context.Context) (string, error) {
if r.rootSubpath != nil {
return *r.rootSubpath, nil
}
q := r.Query.Select("rootSubpath")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A Dagger module.
type Module struct {
Query *querybuilder.Selection
description *string
id *ModuleID
name *string
sdk *string
serve *Void
}
type WithModuleFunc func(r *Module) *Module
// With calls the provided function with current Module.
//
// This is useful for reusability and readability by not breaking the calling chain.
func (r *Module) With(f WithModuleFunc) *Module {
return f(r)
}
// Modules used by this module.
func (r *Module) Dependencies(ctx context.Context) ([]Module, error) {
q := r.Query.Select("dependencies")
q = q.Select("id")
type dependencies struct {
Id ModuleID
}
convert := func(fields []dependencies) []Module {
out := []Module{}
for i := range fields {
val := Module{id: &fields[i].Id}
val.Query = q.Root().Select("loadModuleFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []dependencies
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// The dependencies as configured by the module.
func (r *Module) DependencyConfig(ctx context.Context) ([]ModuleDependency, error) {
q := r.Query.Select("dependencyConfig")
q = q.Select("id")
type dependencyConfig struct {
Id ModuleDependencyID
}
convert := func(fields []dependencyConfig) []ModuleDependency {
out := []ModuleDependency{}
for i := range fields {
val := ModuleDependency{id: &fields[i].Id}
val.Query = q.Root().Select("loadModuleDependencyFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []dependencyConfig
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// The doc string of the module, if any
func (r *Module) Description(ctx context.Context) (string, error) {
if r.description != nil {
return *r.description, nil
}
q := r.Query.Select("description")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The generated files and directories made on top of the module source's context directory.
func (r *Module) GeneratedContextDiff() *Directory {
q := r.Query.Select("generatedContextDiff")
return &Directory{
Query: q,
}
}
// The module source's context plus any configuration and source files created by codegen.
func (r *Module) GeneratedContextDirectory() *Directory {
q := r.Query.Select("generatedContextDirectory")
return &Directory{
Query: q,
}
}
// A unique identifier for this Module.
func (r *Module) ID(ctx context.Context) (ModuleID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response ModuleID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *Module) XXX_GraphQLType() string {
return "Module"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *Module) XXX_GraphQLIDType() string {
return "ModuleID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *Module) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Module) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// Retrieves the module with the objects loaded via its SDK.
func (r *Module) Initialize() *Module {
q := r.Query.Select("initialize")
return &Module{
Query: q,
}
}
// Interfaces served by this module.
func (r *Module) Interfaces(ctx context.Context) ([]TypeDef, error) {
q := r.Query.Select("interfaces")
q = q.Select("id")
type interfaces struct {
Id TypeDefID
}
convert := func(fields []interfaces) []TypeDef {
out := []TypeDef{}
for i := range fields {
val := TypeDef{id: &fields[i].Id}
val.Query = q.Root().Select("loadTypeDefFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []interfaces
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// The name of the module
func (r *Module) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.Query.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Objects served by this module.
func (r *Module) Objects(ctx context.Context) ([]TypeDef, error) {
q := r.Query.Select("objects")
q = q.Select("id")
type objects struct {
Id TypeDefID
}
convert := func(fields []objects) []TypeDef {
out := []TypeDef{}
for i := range fields {
val := TypeDef{id: &fields[i].Id}
val.Query = q.Root().Select("loadTypeDefFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []objects
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// The container that runs the module's entrypoint. It will fail to execute if the module doesn't compile.
func (r *Module) Runtime() *Container {
q := r.Query.Select("runtime")
return &Container{
Query: q,
}
}
// The SDK used by this module. Either a name of a builtin SDK or a module source ref string pointing to the SDK's implementation.
func (r *Module) SDK(ctx context.Context) (string, error) {
if r.sdk != nil {
return *r.sdk, nil
}
q := r.Query.Select("sdk")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Serve a module's API in the current session.
//
// Note: this can only be called once per session. In the future, it could return a stream or service to remove the side effect.
func (r *Module) Serve(ctx context.Context) (Void, error) {
if r.serve != nil {
return *r.serve, nil
}
q := r.Query.Select("serve")
var response Void
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The source for the module.
func (r *Module) Source() *ModuleSource {
q := r.Query.Select("source")
return &ModuleSource{
Query: q,
}
}
// Retrieves the module with the given description
func (r *Module) WithDescription(description string) *Module {
q := r.Query.Select("withDescription")
q = q.Arg("description", description)
return &Module{
Query: q,
}
}
// This module plus the given Interface type and associated functions
func (r *Module) WithInterface(iface *TypeDef) *Module {
assertNotNil("iface", iface)
q := r.Query.Select("withInterface")
q = q.Arg("iface", iface)
return &Module{
Query: q,
}
}
// This module plus the given Object type and associated functions.
func (r *Module) WithObject(object *TypeDef) *Module {
assertNotNil("object", object)
q := r.Query.Select("withObject")
q = q.Arg("object", object)
return &Module{
Query: q,
}
}
// Retrieves the module with basic configuration loaded if present.
func (r *Module) WithSource(source *ModuleSource) *Module {
assertNotNil("source", source)
q := r.Query.Select("withSource")
q = q.Arg("source", source)
return &Module{
Query: q,
}
}
// The configuration of dependency of a module.
type ModuleDependency struct {
Query *querybuilder.Selection
id *ModuleDependencyID
name *string
}
// A unique identifier for this ModuleDependency.
func (r *ModuleDependency) ID(ctx context.Context) (ModuleDependencyID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response ModuleDependencyID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *ModuleDependency) XXX_GraphQLType() string {
return "ModuleDependency"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *ModuleDependency) XXX_GraphQLIDType() string {
return "ModuleDependencyID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *ModuleDependency) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *ModuleDependency) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The name of the dependency module.
func (r *ModuleDependency) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.Query.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The source for the dependency module.
func (r *ModuleDependency) Source() *ModuleSource {
q := r.Query.Select("source")
return &ModuleSource{
Query: q,
}
}
// The source needed to load and run a module, along with any metadata about the source such as versions/urls/etc.
type ModuleSource struct {
Query *querybuilder.Selection
asString *string
configExists *bool
id *ModuleSourceID
kind *ModuleSourceKind
moduleName *string
moduleOriginalName *string
resolveContextPathFromCaller *string
sourceRootSubpath *string
sourceSubpath *string
}
type WithModuleSourceFunc func(r *ModuleSource) *ModuleSource
// With calls the provided function with current ModuleSource.
//
// This is useful for reusability and readability by not breaking the calling chain.
func (r *ModuleSource) With(f WithModuleSourceFunc) *ModuleSource {
return f(r)
}
// If the source is a of kind git, the git source representation of it.
func (r *ModuleSource) AsGitSource() *GitModuleSource {
q := r.Query.Select("asGitSource")
return &GitModuleSource{
Query: q,
}
}
// If the source is of kind local, the local source representation of it.
func (r *ModuleSource) AsLocalSource() *LocalModuleSource {
q := r.Query.Select("asLocalSource")
return &LocalModuleSource{
Query: q,
}
}
// Load the source as a module. If this is a local source, the parent directory must have been provided during module source creation
func (r *ModuleSource) AsModule() *Module {
q := r.Query.Select("asModule")
return &Module{
Query: q,
}
}
// A human readable ref string representation of this module source.
func (r *ModuleSource) AsString(ctx context.Context) (string, error) {
if r.asString != nil {
return *r.asString, nil
}
q := r.Query.Select("asString")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Returns whether the module source has a configuration file.
func (r *ModuleSource) ConfigExists(ctx context.Context) (bool, error) {
if r.configExists != nil {
return *r.configExists, nil
}
q := r.Query.Select("configExists")
var response bool
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The directory containing everything needed to load load and use the module.
func (r *ModuleSource) ContextDirectory() *Directory {
q := r.Query.Select("contextDirectory")
return &Directory{
Query: q,
}
}
// The dependencies of the module source. Includes dependencies from the configuration and any extras from withDependencies calls.
func (r *ModuleSource) Dependencies(ctx context.Context) ([]ModuleDependency, error) {
q := r.Query.Select("dependencies")
q = q.Select("id")
type dependencies struct {
Id ModuleDependencyID
}
convert := func(fields []dependencies) []ModuleDependency {
out := []ModuleDependency{}
for i := range fields {
val := ModuleDependency{id: &fields[i].Id}
val.Query = q.Root().Select("loadModuleDependencyFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []dependencies
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// The directory containing the module configuration and source code (source code may be in a subdir).
func (r *ModuleSource) Directory(path string) *Directory {
q := r.Query.Select("directory")
q = q.Arg("path", path)
return &Directory{
Query: q,
}
}
// A unique identifier for this ModuleSource.
func (r *ModuleSource) ID(ctx context.Context) (ModuleSourceID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response ModuleSourceID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *ModuleSource) XXX_GraphQLType() string {
return "ModuleSource"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *ModuleSource) XXX_GraphQLIDType() string {
return "ModuleSourceID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *ModuleSource) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *ModuleSource) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The kind of source (e.g. local, git, etc.)
func (r *ModuleSource) Kind(ctx context.Context) (ModuleSourceKind, error) {
if r.kind != nil {
return *r.kind, nil
}
q := r.Query.Select("kind")
var response ModuleSourceKind
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// If set, the name of the module this source references, including any overrides at runtime by callers.
func (r *ModuleSource) ModuleName(ctx context.Context) (string, error) {
if r.moduleName != nil {
return *r.moduleName, nil
}
q := r.Query.Select("moduleName")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The original name of the module this source references, as defined in the module configuration.
func (r *ModuleSource) ModuleOriginalName(ctx context.Context) (string, error) {
if r.moduleOriginalName != nil {
return *r.moduleOriginalName, nil
}
q := r.Query.Select("moduleOriginalName")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The path to the module source's context directory on the caller's filesystem. Only valid for local sources.
func (r *ModuleSource) ResolveContextPathFromCaller(ctx context.Context) (string, error) {
if r.resolveContextPathFromCaller != nil {
return *r.resolveContextPathFromCaller, nil
}
q := r.Query.Select("resolveContextPathFromCaller")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Resolve the provided module source arg as a dependency relative to this module source.
func (r *ModuleSource) ResolveDependency(dep *ModuleSource) *ModuleSource {
assertNotNil("dep", dep)
q := r.Query.Select("resolveDependency")
q = q.Arg("dep", dep)
return &ModuleSource{
Query: q,
}
}
// Load the source from its path on the caller's filesystem, including only needed+configured files and directories. Only valid for local sources.
func (r *ModuleSource) ResolveFromCaller() *ModuleSource {
q := r.Query.Select("resolveFromCaller")
return &ModuleSource{
Query: q,
}
}
// The path relative to context of the root of the module source, which contains dagger.json. It also contains the module implementation source code, but that may or may not being a subdir of this root.
func (r *ModuleSource) SourceRootSubpath(ctx context.Context) (string, error) {
if r.sourceRootSubpath != nil {
return *r.sourceRootSubpath, nil
}
q := r.Query.Select("sourceRootSubpath")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The path relative to context of the module implementation source code.
func (r *ModuleSource) SourceSubpath(ctx context.Context) (string, error) {
if r.sourceSubpath != nil {
return *r.sourceSubpath, nil
}
q := r.Query.Select("sourceSubpath")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Update the module source with a new context directory. Only valid for local sources.
func (r *ModuleSource) WithContextDirectory(dir *Directory) *ModuleSource {
assertNotNil("dir", dir)
q := r.Query.Select("withContextDirectory")
q = q.Arg("dir", dir)
return &ModuleSource{
Query: q,
}
}
// Append the provided dependencies to the module source's dependency list.
func (r *ModuleSource) WithDependencies(dependencies []*ModuleDependency) *ModuleSource {
q := r.Query.Select("withDependencies")
q = q.Arg("dependencies", dependencies)
return &ModuleSource{
Query: q,
}
}
// Update the module source with a new name.
func (r *ModuleSource) WithName(name string) *ModuleSource {
q := r.Query.Select("withName")
q = q.Arg("name", name)
return &ModuleSource{
Query: q,
}
}
// Update the module source with a new SDK.
func (r *ModuleSource) WithSDK(sdk string) *ModuleSource {
q := r.Query.Select("withSDK")
q = q.Arg("sdk", sdk)
return &ModuleSource{
Query: q,
}
}
// Update the module source with a new source subpath.
func (r *ModuleSource) WithSourceSubpath(path string) *ModuleSource {
q := r.Query.Select("withSourceSubpath")
q = q.Arg("path", path)
return &ModuleSource{
Query: q,
}
}
// A definition of a custom object defined in a Module.
type ObjectTypeDef struct {
Query *querybuilder.Selection
description *string
id *ObjectTypeDefID
name *string
sourceModuleName *string
}
// The function used to construct new instances of this object, if any
func (r *ObjectTypeDef) Constructor() *Function {
q := r.Query.Select("constructor")
return &Function{
Query: q,
}
}
// The doc string for the object, if any.
func (r *ObjectTypeDef) Description(ctx context.Context) (string, error) {
if r.description != nil {
return *r.description, nil
}
q := r.Query.Select("description")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Static fields defined on this object, if any.
func (r *ObjectTypeDef) Fields(ctx context.Context) ([]FieldTypeDef, error) {
q := r.Query.Select("fields")
q = q.Select("id")
type fields struct {
Id FieldTypeDefID
}
convert := func(fields []fields) []FieldTypeDef {
out := []FieldTypeDef{}
for i := range fields {
val := FieldTypeDef{id: &fields[i].Id}
val.Query = q.Root().Select("loadFieldTypeDefFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []fields
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// Functions defined on this object, if any.
func (r *ObjectTypeDef) Functions(ctx context.Context) ([]Function, error) {
q := r.Query.Select("functions")
q = q.Select("id")
type functions struct {
Id FunctionID
}
convert := func(fields []functions) []Function {
out := []Function{}
for i := range fields {
val := Function{id: &fields[i].Id}
val.Query = q.Root().Select("loadFunctionFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []functions
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// A unique identifier for this ObjectTypeDef.
func (r *ObjectTypeDef) ID(ctx context.Context) (ObjectTypeDefID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response ObjectTypeDefID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *ObjectTypeDef) XXX_GraphQLType() string {
return "ObjectTypeDef"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *ObjectTypeDef) XXX_GraphQLIDType() string {
return "ObjectTypeDefID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *ObjectTypeDef) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *ObjectTypeDef) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The name of the object.
func (r *ObjectTypeDef) Name(ctx context.Context) (string, error) {
if r.name != nil {
return *r.name, nil
}
q := r.Query.Select("name")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// If this ObjectTypeDef is associated with a Module, the name of the module. Unset otherwise.
func (r *ObjectTypeDef) SourceModuleName(ctx context.Context) (string, error) {
if r.sourceModuleName != nil {
return *r.sourceModuleName, nil
}
q := r.Query.Select("sourceModuleName")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A port exposed by a container.
type Port struct {
Query *querybuilder.Selection
description *string
experimentalSkipHealthcheck *bool
id *PortID
port *int
protocol *NetworkProtocol
}
// The port description.
func (r *Port) Description(ctx context.Context) (string, error) {
if r.description != nil {
return *r.description, nil
}
q := r.Query.Select("description")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Skip the health check when run as a service.
func (r *Port) ExperimentalSkipHealthcheck(ctx context.Context) (bool, error) {
if r.experimentalSkipHealthcheck != nil {
return *r.experimentalSkipHealthcheck, nil
}
q := r.Query.Select("experimentalSkipHealthcheck")
var response bool
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A unique identifier for this Port.
func (r *Port) ID(ctx context.Context) (PortID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response PortID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *Port) XXX_GraphQLType() string {
return "Port"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *Port) XXX_GraphQLIDType() string {
return "PortID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *Port) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Port) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The port number.
func (r *Port) Port(ctx context.Context) (int, error) {
if r.port != nil {
return *r.port, nil
}
q := r.Query.Select("port")
var response int
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// The transport layer protocol.
func (r *Port) Protocol(ctx context.Context) (NetworkProtocol, error) {
if r.protocol != nil {
return *r.protocol, nil
}
q := r.Query.Select("protocol")
var response NetworkProtocol
q = q.Bind(&response)
return response, q.Execute(ctx)
}
type WithClientFunc func(r *Client) *Client
// With calls the provided function with current Client.
//
// This is useful for reusability and readability by not breaking the calling chain.
func (r *Client) With(f WithClientFunc) *Client {
return f(r)
}
// Retrieves a content-addressed blob.
func (r *Client) Blob(digest string, size int, mediaType string, uncompressed string) *Directory {
q := r.Query.Select("blob")
q = q.Arg("digest", digest)
q = q.Arg("size", size)
q = q.Arg("mediaType", mediaType)
q = q.Arg("uncompressed", uncompressed)
return &Directory{
Query: q,
}
}
// Retrieves a container builtin to the engine.
func (r *Client) BuiltinContainer(digest string) *Container {
q := r.Query.Select("builtinContainer")
q = q.Arg("digest", digest)
return &Container{
Query: q,
}
}
// Constructs a cache volume for a given cache key.
func (r *Client) CacheVolume(key string) *CacheVolume {
q := r.Query.Select("cacheVolume")
q = q.Arg("key", key)
return &CacheVolume{
Query: q,
}
}
// Checks if the current Dagger Engine is compatible with an SDK's required version.
func (r *Client) CheckVersionCompatibility(ctx context.Context, version string) (bool, error) {
q := r.Query.Select("checkVersionCompatibility")
q = q.Arg("version", version)
var response bool
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// ContainerOpts contains options for Client.Container
type ContainerOpts struct {
// DEPRECATED: Use `loadContainerFromID` instead.
ID ContainerID
// Platform to initialize the container with.
Platform Platform
}
// Creates a scratch container.
//
// Optional platform argument initializes new containers to execute and publish as that platform. Platform defaults to that of the builder's host.
func (r *Client) Container(opts ...ContainerOpts) *Container {
q := r.Query.Select("container")
for i := len(opts) - 1; i >= 0; i-- {
// `id` optional argument
if !querybuilder.IsZeroValue(opts[i].ID) {
q = q.Arg("id", opts[i].ID)
}
// `platform` optional argument
if !querybuilder.IsZeroValue(opts[i].Platform) {
q = q.Arg("platform", opts[i].Platform)
}
}
return &Container{
Query: q,
}
}
// The FunctionCall context that the SDK caller is currently executing in.
//
// If the caller is not currently executing in a function, this will return an error.
func (r *Client) CurrentFunctionCall() *FunctionCall {
q := r.Query.Select("currentFunctionCall")
return &FunctionCall{
Query: q,
}
}
// The module currently being served in the session, if any.
func (r *Client) CurrentModule() *CurrentModule {
q := r.Query.Select("currentModule")
return &CurrentModule{
Query: q,
}
}
// The TypeDef representations of the objects currently being served in the session.
func (r *Client) CurrentTypeDefs(ctx context.Context) ([]TypeDef, error) {
q := r.Query.Select("currentTypeDefs")
q = q.Select("id")
type currentTypeDefs struct {
Id TypeDefID
}
convert := func(fields []currentTypeDefs) []TypeDef {
out := []TypeDef{}
for i := range fields {
val := TypeDef{id: &fields[i].Id}
val.Query = q.Root().Select("loadTypeDefFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []currentTypeDefs
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// The default platform of the engine.
func (r *Client) DefaultPlatform(ctx context.Context) (Platform, error) {
q := r.Query.Select("defaultPlatform")
var response Platform
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// DirectoryOpts contains options for Client.Directory
type DirectoryOpts struct {
// DEPRECATED: Use `loadDirectoryFromID` isntead.
ID DirectoryID
}
// Creates an empty directory.
func (r *Client) Directory(opts ...DirectoryOpts) *Directory {
q := r.Query.Select("directory")
for i := len(opts) - 1; i >= 0; i-- {
// `id` optional argument
if !querybuilder.IsZeroValue(opts[i].ID) {
q = q.Arg("id", opts[i].ID)
}
}
return &Directory{
Query: q,
}
}
// Deprecated: Use LoadFileFromID instead.
func (r *Client) File(id FileID) *File {
q := r.Query.Select("file")
q = q.Arg("id", id)
return &File{
Query: q,
}
}
// Creates a function.
func (r *Client) Function(name string, returnType *TypeDef) *Function {
assertNotNil("returnType", returnType)
q := r.Query.Select("function")
q = q.Arg("name", name)
q = q.Arg("returnType", returnType)
return &Function{
Query: q,
}
}
// Create a code generation result, given a directory containing the generated code.
func (r *Client) GeneratedCode(code *Directory) *GeneratedCode {
assertNotNil("code", code)
q := r.Query.Select("generatedCode")
q = q.Arg("code", code)
return &GeneratedCode{
Query: q,
}
}
// GitOpts contains options for Client.Git
type GitOpts struct {
// Set to true to keep .git directory.
KeepGitDir bool
// A service which must be started before the repo is fetched.
ExperimentalServiceHost *Service
// Set SSH known hosts
SSHKnownHosts string
// Set SSH auth socket
SSHAuthSocket *Socket
}
// Queries a Git repository.
func (r *Client) Git(url string, opts ...GitOpts) *GitRepository {
q := r.Query.Select("git")
for i := len(opts) - 1; i >= 0; i-- {
// `keepGitDir` optional argument
if !querybuilder.IsZeroValue(opts[i].KeepGitDir) {
q = q.Arg("keepGitDir", opts[i].KeepGitDir)
}
// `experimentalServiceHost` optional argument
if !querybuilder.IsZeroValue(opts[i].ExperimentalServiceHost) {
q = q.Arg("experimentalServiceHost", opts[i].ExperimentalServiceHost)
}
// `sshKnownHosts` optional argument
if !querybuilder.IsZeroValue(opts[i].SSHKnownHosts) {
q = q.Arg("sshKnownHosts", opts[i].SSHKnownHosts)
}
// `sshAuthSocket` optional argument
if !querybuilder.IsZeroValue(opts[i].SSHAuthSocket) {
q = q.Arg("sshAuthSocket", opts[i].SSHAuthSocket)
}
}
q = q.Arg("url", url)
return &GitRepository{
Query: q,
}
}
// Queries the host environment.
func (r *Client) Host() *Host {
q := r.Query.Select("host")
return &Host{
Query: q,
}
}
// HTTPOpts contains options for Client.HTTP
type HTTPOpts struct {
// A service which must be started before the URL is fetched.
ExperimentalServiceHost *Service
}
// Returns a file containing an http remote url content.
func (r *Client) HTTP(url string, opts ...HTTPOpts) *File {
q := r.Query.Select("http")
for i := len(opts) - 1; i >= 0; i-- {
// `experimentalServiceHost` optional argument
if !querybuilder.IsZeroValue(opts[i].ExperimentalServiceHost) {
q = q.Arg("experimentalServiceHost", opts[i].ExperimentalServiceHost)
}
}
q = q.Arg("url", url)
return &File{
Query: q,
}
}
// Load a CacheVolume from its ID.
func (r *Client) LoadCacheVolumeFromID(id CacheVolumeID) *CacheVolume {
q := r.Query.Select("loadCacheVolumeFromID")
q = q.Arg("id", id)
return &CacheVolume{
Query: q,
}
}
// Load a Container from its ID.
func (r *Client) LoadContainerFromID(id ContainerID) *Container {
q := r.Query.Select("loadContainerFromID")
q = q.Arg("id", id)
return &Container{
Query: q,
}
}
// Load a CurrentModule from its ID.
func (r *Client) LoadCurrentModuleFromID(id CurrentModuleID) *CurrentModule {
q := r.Query.Select("loadCurrentModuleFromID")
q = q.Arg("id", id)
return &CurrentModule{
Query: q,
}
}
// Load a Directory from its ID.
func (r *Client) LoadDirectoryFromID(id DirectoryID) *Directory {
q := r.Query.Select("loadDirectoryFromID")
q = q.Arg("id", id)
return &Directory{
Query: q,
}
}
// Load a EnvVariable from its ID.
func (r *Client) LoadEnvVariableFromID(id EnvVariableID) *EnvVariable {
q := r.Query.Select("loadEnvVariableFromID")
q = q.Arg("id", id)
return &EnvVariable{
Query: q,
}
}
// Load a FieldTypeDef from its ID.
func (r *Client) LoadFieldTypeDefFromID(id FieldTypeDefID) *FieldTypeDef {
q := r.Query.Select("loadFieldTypeDefFromID")
q = q.Arg("id", id)
return &FieldTypeDef{
Query: q,
}
}
// Load a File from its ID.
func (r *Client) LoadFileFromID(id FileID) *File {
q := r.Query.Select("loadFileFromID")
q = q.Arg("id", id)
return &File{
Query: q,
}
}
// Load a FunctionArg from its ID.
func (r *Client) LoadFunctionArgFromID(id FunctionArgID) *FunctionArg {
q := r.Query.Select("loadFunctionArgFromID")
q = q.Arg("id", id)
return &FunctionArg{
Query: q,
}
}
// Load a FunctionCallArgValue from its ID.
func (r *Client) LoadFunctionCallArgValueFromID(id FunctionCallArgValueID) *FunctionCallArgValue {
q := r.Query.Select("loadFunctionCallArgValueFromID")
q = q.Arg("id", id)
return &FunctionCallArgValue{
Query: q,
}
}
// Load a FunctionCall from its ID.
func (r *Client) LoadFunctionCallFromID(id FunctionCallID) *FunctionCall {
q := r.Query.Select("loadFunctionCallFromID")
q = q.Arg("id", id)
return &FunctionCall{
Query: q,
}
}
// Load a Function from its ID.
func (r *Client) LoadFunctionFromID(id FunctionID) *Function {
q := r.Query.Select("loadFunctionFromID")
q = q.Arg("id", id)
return &Function{
Query: q,
}
}
// Load a GeneratedCode from its ID.
func (r *Client) LoadGeneratedCodeFromID(id GeneratedCodeID) *GeneratedCode {
q := r.Query.Select("loadGeneratedCodeFromID")
q = q.Arg("id", id)
return &GeneratedCode{
Query: q,
}
}
// Load a GitModuleSource from its ID.
func (r *Client) LoadGitModuleSourceFromID(id GitModuleSourceID) *GitModuleSource {
q := r.Query.Select("loadGitModuleSourceFromID")
q = q.Arg("id", id)
return &GitModuleSource{
Query: q,
}
}
// Load a GitRef from its ID.
func (r *Client) LoadGitRefFromID(id GitRefID) *GitRef {
q := r.Query.Select("loadGitRefFromID")
q = q.Arg("id", id)
return &GitRef{
Query: q,
}
}
// Load a GitRepository from its ID.
func (r *Client) LoadGitRepositoryFromID(id GitRepositoryID) *GitRepository {
q := r.Query.Select("loadGitRepositoryFromID")
q = q.Arg("id", id)
return &GitRepository{
Query: q,
}
}
// Load a Host from its ID.
func (r *Client) LoadHostFromID(id HostID) *Host {
q := r.Query.Select("loadHostFromID")
q = q.Arg("id", id)
return &Host{
Query: q,
}
}
// Load a InputTypeDef from its ID.
func (r *Client) LoadInputTypeDefFromID(id InputTypeDefID) *InputTypeDef {
q := r.Query.Select("loadInputTypeDefFromID")
q = q.Arg("id", id)
return &InputTypeDef{
Query: q,
}
}
// Load a InterfaceTypeDef from its ID.
func (r *Client) LoadInterfaceTypeDefFromID(id InterfaceTypeDefID) *InterfaceTypeDef {
q := r.Query.Select("loadInterfaceTypeDefFromID")
q = q.Arg("id", id)
return &InterfaceTypeDef{
Query: q,
}
}
// Load a Label from its ID.
func (r *Client) LoadLabelFromID(id LabelID) *Label {
q := r.Query.Select("loadLabelFromID")
q = q.Arg("id", id)
return &Label{
Query: q,
}
}
// Load a ListTypeDef from its ID.
func (r *Client) LoadListTypeDefFromID(id ListTypeDefID) *ListTypeDef {
q := r.Query.Select("loadListTypeDefFromID")
q = q.Arg("id", id)
return &ListTypeDef{
Query: q,
}
}
// Load a LocalModuleSource from its ID.
func (r *Client) LoadLocalModuleSourceFromID(id LocalModuleSourceID) *LocalModuleSource {
q := r.Query.Select("loadLocalModuleSourceFromID")
q = q.Arg("id", id)
return &LocalModuleSource{
Query: q,
}
}
// Load a ModuleDependency from its ID.
func (r *Client) LoadModuleDependencyFromID(id ModuleDependencyID) *ModuleDependency {
q := r.Query.Select("loadModuleDependencyFromID")
q = q.Arg("id", id)
return &ModuleDependency{
Query: q,
}
}
// Load a Module from its ID.
func (r *Client) LoadModuleFromID(id ModuleID) *Module {
q := r.Query.Select("loadModuleFromID")
q = q.Arg("id", id)
return &Module{
Query: q,
}
}
// Load a ModuleSource from its ID.
func (r *Client) LoadModuleSourceFromID(id ModuleSourceID) *ModuleSource {
q := r.Query.Select("loadModuleSourceFromID")
q = q.Arg("id", id)
return &ModuleSource{
Query: q,
}
}
// Load a ObjectTypeDef from its ID.
func (r *Client) LoadObjectTypeDefFromID(id ObjectTypeDefID) *ObjectTypeDef {
q := r.Query.Select("loadObjectTypeDefFromID")
q = q.Arg("id", id)
return &ObjectTypeDef{
Query: q,
}
}
// Load a Port from its ID.
func (r *Client) LoadPortFromID(id PortID) *Port {
q := r.Query.Select("loadPortFromID")
q = q.Arg("id", id)
return &Port{
Query: q,
}
}
// Load a Secret from its ID.
func (r *Client) LoadSecretFromID(id SecretID) *Secret {
q := r.Query.Select("loadSecretFromID")
q = q.Arg("id", id)
return &Secret{
Query: q,
}
}
// Load a Service from its ID.
func (r *Client) LoadServiceFromID(id ServiceID) *Service {
q := r.Query.Select("loadServiceFromID")
q = q.Arg("id", id)
return &Service{
Query: q,
}
}
// Load a Socket from its ID.
func (r *Client) LoadSocketFromID(id SocketID) *Socket {
q := r.Query.Select("loadSocketFromID")
q = q.Arg("id", id)
return &Socket{
Query: q,
}
}
// Load a Terminal from its ID.
func (r *Client) LoadTerminalFromID(id TerminalID) *Terminal {
q := r.Query.Select("loadTerminalFromID")
q = q.Arg("id", id)
return &Terminal{
Query: q,
}
}
// Load a TypeDef from its ID.
func (r *Client) LoadTypeDefFromID(id TypeDefID) *TypeDef {
q := r.Query.Select("loadTypeDefFromID")
q = q.Arg("id", id)
return &TypeDef{
Query: q,
}
}
// Create a new module.
func (r *Client) Module() *Module {
q := r.Query.Select("module")
return &Module{
Query: q,
}
}
// ModuleDependencyOpts contains options for Client.ModuleDependency
type ModuleDependencyOpts struct {
// If set, the name to use for the dependency. Otherwise, once installed to a parent module, the name of the dependency module will be used by default.
Name string
}
// Create a new module dependency configuration from a module source and name
func (r *Client) ModuleDependency(source *ModuleSource, opts ...ModuleDependencyOpts) *ModuleDependency {
assertNotNil("source", source)
q := r.Query.Select("moduleDependency")
for i := len(opts) - 1; i >= 0; i-- {
// `name` optional argument
if !querybuilder.IsZeroValue(opts[i].Name) {
q = q.Arg("name", opts[i].Name)
}
}
q = q.Arg("source", source)
return &ModuleDependency{
Query: q,
}
}
// ModuleSourceOpts contains options for Client.ModuleSource
type ModuleSourceOpts struct {
// If true, enforce that the source is a stable version for source kinds that support versioning.
Stable bool
}
// Create a new module source instance from a source ref string.
func (r *Client) ModuleSource(refString string, opts ...ModuleSourceOpts) *ModuleSource {
q := r.Query.Select("moduleSource")
for i := len(opts) - 1; i >= 0; i-- {
// `stable` optional argument
if !querybuilder.IsZeroValue(opts[i].Stable) {
q = q.Arg("stable", opts[i].Stable)
}
}
q = q.Arg("refString", refString)
return &ModuleSource{
Query: q,
}
}
// PipelineOpts contains options for Client.Pipeline
type PipelineOpts struct {
// Description of the sub-pipeline.
Description string
// Labels to apply to the sub-pipeline.
Labels []PipelineLabel
}
// Creates a named sub-pipeline.
func (r *Client) Pipeline(name string, opts ...PipelineOpts) *Client {
q := r.Query.Select("pipeline")
for i := len(opts) - 1; i >= 0; i-- {
// `description` optional argument
if !querybuilder.IsZeroValue(opts[i].Description) {
q = q.Arg("description", opts[i].Description)
}
// `labels` optional argument
if !querybuilder.IsZeroValue(opts[i].Labels) {
q = q.Arg("labels", opts[i].Labels)
}
}
q = q.Arg("name", name)
return &Client{
Query: q,
}
}
// SecretOpts contains options for Client.Secret
type SecretOpts struct {
Accessor string
}
// Reference a secret by name.
func (r *Client) Secret(name string, opts ...SecretOpts) *Secret {
q := r.Query.Select("secret")
for i := len(opts) - 1; i >= 0; i-- {
// `accessor` optional argument
if !querybuilder.IsZeroValue(opts[i].Accessor) {
q = q.Arg("accessor", opts[i].Accessor)
}
}
q = q.Arg("name", name)
return &Secret{
Query: q,
}
}
// Sets a secret given a user defined name to its plaintext and returns the secret.
//
// The plaintext value is limited to a size of 128000 bytes.
func (r *Client) SetSecret(name string, plaintext string) *Secret {
q := r.Query.Select("setSecret")
q = q.Arg("name", name)
q = q.Arg("plaintext", plaintext)
return &Secret{
Query: q,
}
}
// Loads a socket by its ID.
//
// Deprecated: Use LoadSocketFromID instead.
func (r *Client) Socket(id SocketID) *Socket {
q := r.Query.Select("socket")
q = q.Arg("id", id)
return &Socket{
Query: q,
}
}
// Create a new TypeDef.
func (r *Client) TypeDef() *TypeDef {
q := r.Query.Select("typeDef")
return &TypeDef{
Query: q,
}
}
// A reference to a secret value, which can be handled more safely than the value itself.
type Secret struct {
Query *querybuilder.Selection
id *SecretID
plaintext *string
}
// A unique identifier for this Secret.
func (r *Secret) ID(ctx context.Context) (SecretID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response SecretID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *Secret) XXX_GraphQLType() string {
return "Secret"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *Secret) XXX_GraphQLIDType() string {
return "SecretID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *Secret) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Secret) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The value of this secret.
func (r *Secret) Plaintext(ctx context.Context) (string, error) {
if r.plaintext != nil {
return *r.plaintext, nil
}
q := r.Query.Select("plaintext")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A content-addressed service providing TCP connectivity.
type Service struct {
Query *querybuilder.Selection
endpoint *string
hostname *string
id *ServiceID
start *ServiceID
stop *ServiceID
up *Void
}
// ServiceEndpointOpts contains options for Service.Endpoint
type ServiceEndpointOpts struct {
// The exposed port number for the endpoint
Port int
// Return a URL with the given scheme, eg. http for http://
Scheme string
}
// Retrieves an endpoint that clients can use to reach this container.
//
// If no port is specified, the first exposed port is used. If none exist an error is returned.
//
// If a scheme is specified, a URL is returned. Otherwise, a host:port pair is returned.
func (r *Service) Endpoint(ctx context.Context, opts ...ServiceEndpointOpts) (string, error) {
if r.endpoint != nil {
return *r.endpoint, nil
}
q := r.Query.Select("endpoint")
for i := len(opts) - 1; i >= 0; i-- {
// `port` optional argument
if !querybuilder.IsZeroValue(opts[i].Port) {
q = q.Arg("port", opts[i].Port)
}
// `scheme` optional argument
if !querybuilder.IsZeroValue(opts[i].Scheme) {
q = q.Arg("scheme", opts[i].Scheme)
}
}
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Retrieves a hostname which can be used by clients to reach this container.
func (r *Service) Hostname(ctx context.Context) (string, error) {
if r.hostname != nil {
return *r.hostname, nil
}
q := r.Query.Select("hostname")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A unique identifier for this Service.
func (r *Service) ID(ctx context.Context) (ServiceID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response ServiceID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *Service) XXX_GraphQLType() string {
return "Service"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *Service) XXX_GraphQLIDType() string {
return "ServiceID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *Service) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Service) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// Retrieves the list of ports provided by the service.
func (r *Service) Ports(ctx context.Context) ([]Port, error) {
q := r.Query.Select("ports")
q = q.Select("id")
type ports struct {
Id PortID
}
convert := func(fields []ports) []Port {
out := []Port{}
for i := range fields {
val := Port{id: &fields[i].Id}
val.Query = q.Root().Select("loadPortFromID").Arg("id", fields[i].Id)
out = append(out, val)
}
return out
}
var response []ports
q = q.Bind(&response)
err := q.Execute(ctx)
if err != nil {
return nil, err
}
return convert(response), nil
}
// Start the service and wait for its health checks to succeed.
//
// Services bound to a Container do not need to be manually started.
func (r *Service) Start(ctx context.Context) (*Service, error) {
q := r.Query.Select("start")
return r, q.Execute(ctx)
}
// ServiceStopOpts contains options for Service.Stop
type ServiceStopOpts struct {
// Immediately kill the service without waiting for a graceful exit
Kill bool
}
// Stop the service.
func (r *Service) Stop(ctx context.Context, opts ...ServiceStopOpts) (*Service, error) {
q := r.Query.Select("stop")
for i := len(opts) - 1; i >= 0; i-- {
// `kill` optional argument
if !querybuilder.IsZeroValue(opts[i].Kill) {
q = q.Arg("kill", opts[i].Kill)
}
}
return r, q.Execute(ctx)
}
// ServiceUpOpts contains options for Service.Up
type ServiceUpOpts struct {
// List of frontend/backend port mappings to forward.
//
// Frontend is the port accepting traffic on the host, backend is the service port.
Ports []PortForward
// Bind each tunnel port to a random port on the host.
Random bool
}
// Creates a tunnel that forwards traffic from the caller's network to this service.
func (r *Service) Up(ctx context.Context, opts ...ServiceUpOpts) (Void, error) {
if r.up != nil {
return *r.up, nil
}
q := r.Query.Select("up")
for i := len(opts) - 1; i >= 0; i-- {
// `ports` optional argument
if !querybuilder.IsZeroValue(opts[i].Ports) {
q = q.Arg("ports", opts[i].Ports)
}
// `random` optional argument
if !querybuilder.IsZeroValue(opts[i].Random) {
q = q.Arg("random", opts[i].Random)
}
}
var response Void
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A Unix or TCP/IP socket that can be mounted into a container.
type Socket struct {
Query *querybuilder.Selection
id *SocketID
}
// A unique identifier for this Socket.
func (r *Socket) ID(ctx context.Context) (SocketID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response SocketID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *Socket) XXX_GraphQLType() string {
return "Socket"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *Socket) XXX_GraphQLIDType() string {
return "SocketID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *Socket) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Socket) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// An interactive terminal that clients can connect to.
type Terminal struct {
Query *querybuilder.Selection
id *TerminalID
websocketEndpoint *string
}
// A unique identifier for this Terminal.
func (r *Terminal) ID(ctx context.Context) (TerminalID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response TerminalID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *Terminal) XXX_GraphQLType() string {
return "Terminal"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *Terminal) XXX_GraphQLIDType() string {
return "TerminalID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *Terminal) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *Terminal) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// An http endpoint at which this terminal can be connected to over a websocket.
func (r *Terminal) WebsocketEndpoint(ctx context.Context) (string, error) {
if r.websocketEndpoint != nil {
return *r.websocketEndpoint, nil
}
q := r.Query.Select("websocketEndpoint")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// A definition of a parameter or return type in a Module.
type TypeDef struct {
Query *querybuilder.Selection
id *TypeDefID
kind *TypeDefKind
optional *bool
}
type WithTypeDefFunc func(r *TypeDef) *TypeDef
// With calls the provided function with current TypeDef.
//
// This is useful for reusability and readability by not breaking the calling chain.
func (r *TypeDef) With(f WithTypeDefFunc) *TypeDef {
return f(r)
}
// If kind is INPUT, the input-specific type definition. If kind is not INPUT, this will be null.
func (r *TypeDef) AsInput() *InputTypeDef {
q := r.Query.Select("asInput")
return &InputTypeDef{
Query: q,
}
}
// If kind is INTERFACE, the interface-specific type definition. If kind is not INTERFACE, this will be null.
func (r *TypeDef) AsInterface() *InterfaceTypeDef {
q := r.Query.Select("asInterface")
return &InterfaceTypeDef{
Query: q,
}
}
// If kind is LIST, the list-specific type definition. If kind is not LIST, this will be null.
func (r *TypeDef) AsList() *ListTypeDef {
q := r.Query.Select("asList")
return &ListTypeDef{
Query: q,
}
}
// If kind is OBJECT, the object-specific type definition. If kind is not OBJECT, this will be null.
func (r *TypeDef) AsObject() *ObjectTypeDef {
q := r.Query.Select("asObject")
return &ObjectTypeDef{
Query: q,
}
}
// A unique identifier for this TypeDef.
func (r *TypeDef) ID(ctx context.Context) (TypeDefID, error) {
if r.id != nil {
return *r.id, nil
}
q := r.Query.Select("id")
var response TypeDefID
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// XXX_GraphQLType is an internal function. It returns the native GraphQL type name
func (r *TypeDef) XXX_GraphQLType() string {
return "TypeDef"
}
// XXX_GraphQLIDType is an internal function. It returns the native GraphQL type name for the ID of this object
func (r *TypeDef) XXX_GraphQLIDType() string {
return "TypeDefID"
}
// XXX_GraphQLID is an internal function. It returns the underlying type ID
func (r *TypeDef) XXX_GraphQLID(ctx context.Context) (string, error) {
id, err := r.ID(ctx)
if err != nil {
return "", err
}
return string(id), nil
}
func (r *TypeDef) MarshalJSON() ([]byte, error) {
id, err := r.ID(context.Background())
if err != nil {
return nil, err
}
return json.Marshal(id)
}
// The kind of type this is (e.g. primitive, list, object).
func (r *TypeDef) Kind(ctx context.Context) (TypeDefKind, error) {
if r.kind != nil {
return *r.kind, nil
}
q := r.Query.Select("kind")
var response TypeDefKind
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Whether this type can be set to null. Defaults to false.
func (r *TypeDef) Optional(ctx context.Context) (bool, error) {
if r.optional != nil {
return *r.optional, nil
}
q := r.Query.Select("optional")
var response bool
q = q.Bind(&response)
return response, q.Execute(ctx)
}
// Adds a function for constructing a new instance of an Object TypeDef, failing if the type is not an object.
func (r *TypeDef) WithConstructor(function *Function) *TypeDef {
assertNotNil("function", function)
q := r.Query.Select("withConstructor")
q = q.Arg("function", function)
return &TypeDef{
Query: q,
}
}
// TypeDefWithFieldOpts contains options for TypeDef.WithField
type TypeDefWithFieldOpts struct {
// A doc string for the field, if any
Description string
}
// Adds a static field for an Object TypeDef, failing if the type is not an object.
func (r *TypeDef) WithField(name string, typeDef *TypeDef, opts ...TypeDefWithFieldOpts) *TypeDef {
assertNotNil("typeDef", typeDef)
q := r.Query.Select("withField")
for i := len(opts) - 1; i >= 0; i-- {
// `description` optional argument
if !querybuilder.IsZeroValue(opts[i].Description) {
q = q.Arg("description", opts[i].Description)
}
}
q = q.Arg("name", name)
q = q.Arg("typeDef", typeDef)
return &TypeDef{
Query: q,
}
}
// Adds a function for an Object or Interface TypeDef, failing if the type is not one of those kinds.
func (r *TypeDef) WithFunction(function *Function) *TypeDef {
assertNotNil("function", function)
q := r.Query.Select("withFunction")
q = q.Arg("function", function)
return &TypeDef{
Query: q,
}
}
// TypeDefWithInterfaceOpts contains options for TypeDef.WithInterface
type TypeDefWithInterfaceOpts struct {
Description string
}
// Returns a TypeDef of kind Interface with the provided name.
func (r *TypeDef) WithInterface(name string, opts ...TypeDefWithInterfaceOpts) *TypeDef {
q := r.Query.Select("withInterface")
for i := len(opts) - 1; i >= 0; i-- {
// `description` optional argument
if !querybuilder.IsZeroValue(opts[i].Description) {
q = q.Arg("description", opts[i].Description)
}
}
q = q.Arg("name", name)
return &TypeDef{
Query: q,
}
}
// Sets the kind of the type.
func (r *TypeDef) WithKind(kind TypeDefKind) *TypeDef {
q := r.Query.Select("withKind")
q = q.Arg("kind", kind)
return &TypeDef{
Query: q,
}
}
// Returns a TypeDef of kind List with the provided type for its elements.
func (r *TypeDef) WithListOf(elementType *TypeDef) *TypeDef {
assertNotNil("elementType", elementType)
q := r.Query.Select("withListOf")
q = q.Arg("elementType", elementType)
return &TypeDef{
Query: q,
}
}
// TypeDefWithObjectOpts contains options for TypeDef.WithObject
type TypeDefWithObjectOpts struct {
Description string
}
// Returns a TypeDef of kind Object with the provided name.
//
// Note that an object's fields and functions may be omitted if the intent is only to refer to an object. This is how functions are able to return their own object, or any other circular reference.
func (r *TypeDef) WithObject(name string, opts ...TypeDefWithObjectOpts) *TypeDef {
q := r.Query.Select("withObject")
for i := len(opts) - 1; i >= 0; i-- {
// `description` optional argument
if !querybuilder.IsZeroValue(opts[i].Description) {
q = q.Arg("description", opts[i].Description)
}
}
q = q.Arg("name", name)
return &TypeDef{
Query: q,
}
}
// Sets whether this type can be set to null.
func (r *TypeDef) WithOptional(optional bool) *TypeDef {
q := r.Query.Select("withOptional")
q = q.Arg("optional", optional)
return &TypeDef{
Query: q,
}
}
type CacheSharingMode string
func (CacheSharingMode) IsEnum() {}
const (
// Shares the cache volume amongst many build pipelines, but will serialize the writes
Locked CacheSharingMode = "LOCKED"
// Keeps a cache volume for a single build pipeline
Private CacheSharingMode = "PRIVATE"
// Shares the cache volume amongst many build pipelines
Shared CacheSharingMode = "SHARED"
)
type ImageLayerCompression string
func (ImageLayerCompression) IsEnum() {}
const (
Estargz ImageLayerCompression = "EStarGZ"
Gzip ImageLayerCompression = "Gzip"
Uncompressed ImageLayerCompression = "Uncompressed"
Zstd ImageLayerCompression = "Zstd"
)
type ImageMediaTypes string
func (ImageMediaTypes) IsEnum() {}
const (
Dockermediatypes ImageMediaTypes = "DockerMediaTypes"
Ocimediatypes ImageMediaTypes = "OCIMediaTypes"
)
type ModuleSourceKind string
func (ModuleSourceKind) IsEnum() {}
const (
GitSource ModuleSourceKind = "GIT_SOURCE"
LocalSource ModuleSourceKind = "LOCAL_SOURCE"
)
type NetworkProtocol string
func (NetworkProtocol) IsEnum() {}
const (
Tcp NetworkProtocol = "TCP"
Udp NetworkProtocol = "UDP"
)
type TypeDefKind string
func (TypeDefKind) IsEnum() {}
const (
// A boolean value.
BooleanKind TypeDefKind = "BOOLEAN_KIND"
// A graphql input type, used only when representing the core API via TypeDefs.
InputKind TypeDefKind = "INPUT_KIND"
// An integer value.
IntegerKind TypeDefKind = "INTEGER_KIND"
// A named type of functions that can be matched+implemented by other objects+interfaces.
//
// Always paired with an InterfaceTypeDef.
InterfaceKind TypeDefKind = "INTERFACE_KIND"
// A list of values all having the same type.
//
// Always paired with a ListTypeDef.
ListKind TypeDefKind = "LIST_KIND"
// A named type defined in the GraphQL schema, with fields and functions.
//
// Always paired with an ObjectTypeDef.
ObjectKind TypeDefKind = "OBJECT_KIND"
// A string value.
StringKind TypeDefKind = "STRING_KIND"
// A special kind used to signify that no value is returned.
//
// This is used for functions that have no return value. The outer TypeDef specifying this Kind is always Optional, as the Void is never actually represented.
VoidKind TypeDefKind = "VOID_KIND"
)
|