diff --git a/.cspell.json b/.cspell.json index 71ced17ccf..09a12d9caa 100644 --- a/.cspell.json +++ b/.cspell.json @@ -1,226 +1,3448 @@ { "version": "0.2", "language": "en", - "words": [ - "ACCESSS", + "import": [ + "@cspell/dict-cpp/cspell-ext.json", + "@cspell/dict-docker/cspell-ext.json", + "@cspell/dict-en_us/cspell-ext.json", + "@cspell/dict-fullstack/cspell-ext.json", + "@cspell/dict-git/cspell-ext.json", + "@cspell/dict-golang/cspell-ext.json", + "@cspell/dict-k8s/cspell-ext.json", + "@cspell/dict-makefile/cspell-ext.json", + "@cspell/dict-markdown/cspell-ext.json", + "@cspell/dict-npm/cspell-ext.json", + "@cspell/dict-public-licenses/cspell-ext.json", + "@cspell/dict-rust/cspell-ext.json", + "@cspell/dict-shell/cspell-ext.json" + ], + "ignorePaths": [ + "**/*.ai", + "**/*.drawio", + "**/*.hdf5", + "**/*.key", + "**/*.lock", + "**/*.log", + "**/*.md5", + "**/*.pack", + "**/*.pdf", + "**/*.pem", + "**/*.png", + "**/*.sum", + "**/*.svg", + "**/.cspell.json", + "**/.git/objects/**", + "**/cmd/agent/core/faiss/faiss", + "**/cmd/agent/core/ngt/ngt", + "**/cmd/agent/sidecar/sidecar", + "**/cmd/discoverer/k8s/discoverer", + "**/cmd/gateway/filter/filter", + "**/cmd/gateway/lb/lb", + "**/cmd/gateway/mirror/mirror", + "**/cmd/index/job/correction/index-correction", + "**/cmd/index/job/creation/index-creation", + "**/cmd/index/job/readreplica/rotate/readreplica-rotate", + "**/cmd/index/job/save/index-save", + "**/cmd/index/operator/index-operator", + "**/cmd/manager/index/index", + "**/cmd/tools/benchmark/job/job", + "**/cmd/tools/benchmark/operator/operator", + "**/cmd/tools/cli/loadtest/loadtest", + "**/hack/cspell/**", + "**/internal/core/algorithm/ngt/assets/index", + "**/internal/test/data/agent/ngt/validIndex" + ], + "patterns": [ + { + "name": "Ignore_addr_suffix", + "pattern": "/\\b\\w*addr\\b/" + }, + { + "name": "Ignore_addrs_suffix", + "pattern": "/\\b\\w*addrs\\b/" + }, + { + "name": "Ignore_buf_suffix", + "pattern": "/\\b\\w*buf\\b/" + }, + { + "name": "Ignore_cancel_suffix", + "pattern": "/\\b\\w*cancel\\b/" + }, + { + "name": "Ignore_cfg_suffix", + "pattern": "/\\b\\w*cfg\\b/" + }, + { + "name": "Ignore_ch_suffix", + "pattern": "/\\b\\w*ch\\b/" + }, + { + "name": "Ignore_cnt_suffix", + "pattern": "/\\b\\w*cnt\\b/" + }, + { + "name": "Ignore_conf_suffix", + "pattern": "/\\b\\w*conf\\b/" + }, + { + "name": "Ignore_conn_suffix", + "pattern": "/\\b\\w*conn\\b/" + }, + { + "name": "Ignore_ctx_suffix", + "pattern": "/\\b\\w*ctx\\b/" + }, + { + "name": "Ignore_dim_suffix", + "pattern": "/\\b\\w*dim\\b/" + }, + { + "name": "Ignore_dur_suffix", + "pattern": "/\\b\\w*dur\\b/" + }, + { + "name": "Ignore_env_suffix", + "pattern": "/\\b\\w*env\\b/" + }, + { + "name": "Ignore_err_suffix", + "pattern": "/\\b\\w*err\\b/" + }, + { + "name": "Ignore_error_suffix", + "pattern": "/\\b\\w*error\\b/" + }, + { + "name": "Ignore_errors_suffix", + "pattern": "/\\b\\w*errors\\b/" + }, + { + "name": "Ignore_errs_suffix", + "pattern": "/\\b\\w*errs\\b/" + }, + { + "name": "Ignore_idx_suffix", + "pattern": "/\\b\\w*idx\\b/" + }, + { + "name": "Ignore_len_suffix", + "pattern": "/\\b\\w*len\\b/" + }, + { + "name": "Ignore_mu_suffix", + "pattern": "/\\b\\w*mu\\b/" + }, + { + "name": "Ignore_opt_suffix", + "pattern": "/\\b\\w*opt\\b/" + }, + { + "name": "Ignore_opts_suffix", + "pattern": "/\\b\\w*opts\\b/" + }, + { + "name": "Ignore_pool_suffix", + "pattern": "/\\b\\w*pool\\b/" + }, + { + "name": "Ignore_req_suffix", + "pattern": "/\\b\\w*req\\b/" + }, + { + "name": "Ignore_res_suffix", + "pattern": "/\\b\\w*res\\b/" + }, + { + "name": "Ignore_size_suffix", + "pattern": "/\\b\\w*size\\b/" + }, + { + "name": "Ignore_vec_suffix", + "pattern": "/\\b\\w*vec\\b/" + } + ], + "ignoreRegExpList": [ + "Ignore_addr_suffix", + "Ignore_addrs_suffix", + "Ignore_buf_suffix", + "Ignore_cancel_suffix", + "Ignore_cfg_suffix", + "Ignore_ch_suffix", + "Ignore_cnt_suffix", + "Ignore_conf_suffix", + "Ignore_conn_suffix", + "Ignore_ctx_suffix", + "Ignore_dim_suffix", + "Ignore_dur_suffix", + "Ignore_env_suffix", + "Ignore_err_suffix", + "Ignore_error_suffix", + "Ignore_errors_suffix", + "Ignore_errs_suffix", + "Ignore_idx_suffix", + "Ignore_len_suffix", + "Ignore_mu_suffix", + "Ignore_opt_suffix", + "Ignore_opts_suffix", + "Ignore_pool_suffix", + "Ignore_req_suffix", + "Ignore_res_suffix", + "Ignore_size_suffix", + "Ignore_vec_suffix" + ], + "ignoreWords": [ "AQUASECURITY", - "AUTOBUILD", + "Addrs", + "Atof", + "Atol", + "Autoscaler", + "BINFMT", + "BUILDBASE", + "BUILDKIT", "BUILDX", - "Burstable", + "Bbolt", + "Buildx", + "CAPI", + "CHATOPS", "Capi", + "DISTROLESS", + "DNSA", + "Debugd", + "Debugf", + "Devcontainer", + "EUCJP", + "Errord", "Errorf", + "Eucjp", "FAISS", + "FASTOPEN", + "Faiss", + "Fatald", + "Fnum", + "GACHE", + "GETOBJECT", "GHACTION", + "GOARCH", + "GOBIN", "GOLANGCILINT", - "GOMAXPROCS", - "Godoc", + "GOLINES", + "GOPATH", + "GOPKG", + "GOPRIVATE", + "GOROOT", + "GOTEST", + "GOTESTS", + "Gache", + "Gocqlx", + "Gofumpt", + "Goleak", + "IDRPC", + "INITCONTAINER", + "Idxs", + "Iface", + "Indegree", + "Infod", "Infof", + "Inuse", + "Jaccard", + "KEEPIDLE", + "KEYSPACE", + "KLOG", + "KUBECONFIG", "KUBELINTER", + "KVSDB", + "Keyspace", + "Kvsdb", "LANGUAGETOOL", - "Milli", + "LDFLAGS", + "LOADTEST", + "LOGRUS", + "LOGRUs", + "MNIST", + "Mallocs", + "Mirr", + "Nbits", + "Nocie", "ONNX", - "OTEL", - "PROTOBUF", + "Oneof", + "Outdegree", + "Outf", + "PORTFORWARD", + "Portforward", + "Prost", + "Ptop", + "Pyroscope", + "QUICKACK", + "RDONLY", + "READREPLICA", + "RECVORIGDSTADDR", "REVIEWDOG", - "Roundtripper", + "ROOTDIR", + "RUSTUP", + "Readreplica", + "Rebalance", + "Regist", + "Represets", + "Retryable", + "Reviewdog", + "Rootdir", + "Ruleguard", "SARIF", - "SOFTPROPS", - "Structs", + "SYFT", + "Sjis", + "Stmts", + "Struct", + "Svcs", "TELEPRESENCE", + "TEXTLINT", + "TMPDIR", + "Tgts", + "Tolerations", + "UPSERT", + "Unmarshal", + "Upsert", "VALD", - "VALDCLI", + "VALDRELEASE", + "VECTORIZER", "VHOR", "Vald", + "Vald's", + "Vals", + "Vecs", "Vectorizer", + "Vqueue", + "Warnd", + "Warnf", + "Wrapf", + "ZEROLOG", + "ZSTD", + "Zstd", + "accesskey", "accesslog", - "achive", + "adal", "addrs", + "adipisicing", + "afero", + "aggr", + "ajstarks", + "aknishid", + "akrylysov", + "aliqua", + "aliquip", + "alives", + "amet", + "amqp", + "ando", + "antihax", + "anypb", + "apiextensions", + "apimachinery", "apiserver", - "attirbute", + "appengine", + "aquasecurity", + "armon", + "astcopy", + "astequal", + "atof", + "atol", + "atot", + "aute", + "autobuild", + "autoclean", + "automaxprocs", + "autoremove", + "autorest", + "autoscaler", + "azcore", + "azidentity", + "backoffmetrics", + "batchv", "bbolt", - "boudary", - "brandguidelines", + "bdbs", + "benbjohnson", + "benchjob", + "benchjobs", + "benchmem", + "benchscenario", + "bento", + "beorn", + "bigann", + "binfmt", + "bjns", + "blackfriday", + "bmizerany", + "boolint", + "boombuler", + "brnd", + "buckhash", + "bufbuild", + "buger", "buildbase", + "buildkit", + "buildx", + "bulkinsert", + "burstable", + "bvecs", + "bytefmt", + "bzrignore", + "canceld", + "capi", + "cbmetrics", + "cenkalti", + "cespare", "chatops", - "chrono", + "chunkreader", + "chzyer", + "cillum", "circuitbreaker", + "clientip", + "clientmock", + "clientset", + "cloudfoundry", + "cloudsql", "cloudstorage", "clusterrole", "clusterrolebinding", + "clusterrolebindings", + "clusterroles", + "cmder", + "cmdflag", + "cmps", + "cnts", + "cockroachdb", + "codegen", + "collatz", + "colorstring", + "commandhistory", + "commodo", + "concurency", "configmap", + "configsources", + "conflint", + "consequat", + "consistetncy", "contributorsrc", "conv", + "copylocks", + "corev", + "cpuguy", + "cpuid", "crds", + "creack", + "createandsave", "crlfmt", + "crorg", + "cstring", "ctxio", + "cupidatat", + "customresourcedefinitions", + "cvspq", "daemonset", + "dataspace", + "datelier", + "davecgh", + "dbuild", + "dbus", + "dcmake", + "deafult", + "debg", + "debugd", + "debugf", + "decbytes", + "deepcopy", "deepsource", + "dejavu", + "deletecollection", + "deleter", + "demangle", + "denisenkom", + "deserunt", "devcontainer", + "devcontainers", "devel", + "devigned", + "dgryski", + "dicoverer", + "difflib", + "diskv", + "distroless", + "dnaeon", + "dnsa", + "dockerfiles", + "dolore", + "dotdc", + "dotproduct", + "dpkg", + "dset", + "duis", + "durationpb", + "dylib", + "easyjson", + "ecrud", + "eiusmod", + "elif", + "elit", + "emap", + "emicklei", + "enim", + "envkey", "envoyproxy", + "eoptions", + "errcheck", "errdetails", "errgroup", - "facebookresearch", + "errgroup", + "errord", + "errorf", + "errorln", + "esac", + "eucjp", + "evanphx", + "eventstream", + "excepteur", + "exhaustruct", + "extendee", + "extldflags", + "faild", "faiss", "fastime", + "fastopen", + "fastuuid", + "fatald", + "felixge", + "fgprof", + "finalizer", + "finalizers", + "firestore", + "fitos", + "flamegraph", + "flot", + "fmap", + "fname", + "fnum", + "fogleman", + "fopenmp", + "fortytw", + "fpdf", + "frankban", + "freelist", + "freetype", + "fsnotify", + "fugiat", "fuid", + "funakoshi", + "fvecs", "gache", + "gbackoff", + "gcsblob", + "genproto", "getobject", "getstarted", + "gfortran", + "ghaction", + "ghcrorg", "gitfiles", + "glfw", + "glog", + "goarch", + "goautoneg", + "gobc", + "gobin", + "gobwas", + "gocache", + "goccy", + "gocloud", + "gocql", + "gocqlx", + "gocraft", + "godbus", + "godebug", + "godeltaprof", + "godoc", + "gofpdf", + "gofpdi", + "gofrs", "gofumpt", + "gofuzz", + "gogrep", "goimports", + "gojsonpointer", + "gojsonreference", + "gojsonschema", "golangci", + "golangcilint", "goleak", "golines", - "gongt", + "gomaxprocs", + "gomega", + "gomnd", + "gomodifytags", + "gomodules", + "gonic", "gonum", + "gopath", + "gopkg", + "gopls", + "goprivate", + "goproxy", + "gopter", + "goroot", + "goroutines", "gorules", + "gostub", "gotest", + "gotestfmt", "gotests", "gotmpl", + "gotool", + "gover", + "govet", + "gpgsign", + "graphviz", + "gregjones", + "grimaud", + "groundtruth", + "groupcache", + "grpclog", + "grpcmock", + "grpcreplay", "hadolint", + "hailocab", + "hanwen", + "healthcheck", + "healthz", "helmignore", - "httputil", - "icfg", + "hgignore", + "hiroto", + "hlts", + "hoge", + "honnef", + "horizontalpodautoscalers", + "hostport", + "hrichik", + "hrichiksite", + "httpcache", + "httpfs", + "httphead", + "httpreplay", + "iancoleman", + "ianlancetaylor", + "iblob", + "iconfig", + "idelay", + "idrpc", + "idxs", + "iface", + "igmp", + "imds", + "incididunt", + "inconshreveable", + "indegree", + "indexmapkey", + "indexmapvalue", + "infod", + "infof", + "infoln", + "infometrics", + "ingester", "initcontainer", + "initdb", + "inmemory", "innerproduct", - "ioutil", + "insuffcient", + "inuse", + "irure", + "isatty", + "ivecs", "jaccard", - "japansearch", + "jackc", + "jaegertracing", + "jessevdk", + "jitted", + "jmespath", + "jmoiron", + "joho", + "josharian", + "jrnlw", + "jsonparser", + "jsonpointer", + "jsonreference", + "jstemmer", + "junsei", + "kadowaki", + "kato", + "katz", + "kbps", + "keepalive", + "keepalives", + "keepidle", + "kevindiu", + "keyspace", + "kiichiro", + "kisielk", + "klauspost", + "klog", + "kmrmt", + "koichi", "kosarak", + "kosuke", "kpango", + "kprofefe", + "kubeconfig", "kubelinter", - "kustomization", + "kubeval", "kvsdb", + "kvstore", + "kvvk", + "kylelemons", + "labelmap", + "labore", + "laboris", + "laborum", + "languagetool", + "ldconfig", + "ldflags", + "leaktest", + "leanovate", + "lenmapkey", + "lenmapvalue", + "leodido", + "lfaiss", + "libaec", "libhdf", + "liblapack", + "libomp", + "libopenblas", + "lifecycler", + "liggitt", + "liusy", + "livenesss", + "lngt", "loadbalancer", "loadtest", + "localserial", + "localtime", + "logex", + "logfmt", + "logr", + "logrus", + "ltsv", + "lucasb", "lycorp", + "mailru", + "mallocs", + "mapkey", + "mapvalue", + "mattn", + "matttproud", "maxprocs", - "minio", + "mazumder", + "mcache", + "memstats", + "mertics", + "metas", + "metav", + "metricinterceptor", + "mfridman", + "miette", + "minburst", + "mirr", + "misscheduled", + "mitchellh", + "mktemp", + "mktmp", "mnist", + "mnode", + "moby", + "modocache", + "mollit", + "monochromegane", + "montanaflynn", + "morimoto", + "mountinfo", + "mpod", + "mspan", + "mssqldb", + "mthe", "multiapis", "multicluster", - "nanos", + "munnerz", + "nang", "nbits", - "networkpolicy", + "ncos", + "neighors", + "networkpolicies", + "ngroup", + "ngtd", + "nhooyr", + "niemeyer", + "nindent", "nlist", + "nobic", + "nocie", + "nogce", + "nolint", + "noninteractive", + "nonroot", + "nopvq", "normalizedangle", "normalizedcosine", + "normalizedl", + "normang", + "normcos", + "norml", "nosql", + "nostrud", + "notests", + "npoints", + "ntotal", + "nulla", + "nvim", + "nvimlog", + "nxadm", "nytimes", + "objc", + "objs", + "objx", + "occaecat", + "ocsql", + "officia", + "okamura", "oneof", "onnx", - "otel", - "otlp", + "onsi", + "opencensus", + "opencontainers", + "osdk", + "ospace", + "otelgrpc", + "otlpmetric", + "otlpmetricgrpc", + "otlptrace", + "otlptracegrpc", + "outdegree", + "outf", + "pariatur", + "pbdocs", + "pbgos", + "peakrate", + "persistentvolumeclaims", + "peterbourgon", + "pflag", + "pgio", + "pgmock", + "pgpassfile", + "pgproto", + "pgroup", + "pgservicefile", + "pgtype", + "phpdave", + "pierrec", + "pipefail", + "pipeliner", + "planetscale", + "pmezard", + "poddisruptionbudgets", + "podname", "pogreb", + "poinc", + "pointradius", "portforward", "pprof", - "priorityclass", + "prashantv", + "preriodically", + "priorityclasses", "profefe", + "progressbar", + "proident", "promtail", "prost", "protobuf", "protoc", + "protocolbuffers", + "protohelpers", + "protoimpl", + "protojson", + "protoreflect", "protos", + "protovalidate", + "pstartf", + "pstopf", + "ptop", "pyroscope", + "quantizer", + "quasilyte", + "queryx", + "quickack", + "quicktest", + "quis", + "ratelimit", + "rdonly", "readreplica", + "readyz", "rebalance", "rebalancing", + "recvorigdstaddr", + "regist", + "registerers", + "replayers", "replicasets", + "repr", + "reprehenderit", + "represets", "rerank", - "retrive", + "resered", + "retryable", "reviewdog", + "rgba", + "rintaro", + "rinx", + "roccd", + "rogpeppe", + "rolebindings", + "rootdir", + "roundtripper", + "rpcs", + "ruleguard", + "russross", "rustc", "rustup", - "serviceaccount", + "ruudk", + "sarif", + "saveindex", + "sbinet", + "schollz", + "scylladb", + "secretkey", + "secretmanager", + "semconv", + "sendemail", + "sergi", + "serversscheme", + "serviceaccounts", + "sess", + "sgroup", + "shiraishi", + "shlex", + "shmem", + "shogo", + "shopspring", + "shurcoo", + "signingkey", + "signoff", "singleflight", + "sint", + "sirupsen", + "siyuan", + "sjis", + "skipcq", + "smallscreen", + "snapshotter", + "snapshotv", + "softprops", + "sparsejaccard", + "spdystream", + "spjac", + "sptag", + "sqlexp", + "sqlmock", + "sqlx", + "srvs", + "sspan", + "stackdriver", + "starlark", "statefulset", - "steamsearch", + "statefulsets", + "staticcheck", + "stdinfo", + "stdr", + "stix", + "stmts", + "stockout", + "stoewer", + "storageclass", + "stos", + "strcase", "streaminsert", + "stretchr", + "strg", + "strictgoimports", + "strparse", + "struct", "structs", + "subquantizers", + "substr", "subtests", - "testdata", - "textlintrc", + "sunt", + "svcs", + "syft", + "tabwriter", + "tada", + "tagalign", + "taisuou", + "takuyaymd", + "tcql", + "technote", + "telepresence", + "tempor", + "testfunc", + "textlint", + "tgts", + "thedrow", + "threadcreate", + "timelimit", + "timepicker", "timeutil", + "tlsca", + "tmpdir", + "tmpfs", + "tmpl", + "tmproj", + "tolerations", + "tonistiigi", + "toolsmith", + "tparse", + "traceinterceptor", "traefik", + "treeprint", + "trunc", + "typeparams", + "tzdata", + "udpa", + "ugorji", + "ullamco", + "ultiple", + "unbackupped", + "unixgram", + "unixpacket", + "unmarshal", + "unparam", "upsert", "upserted", "urlopener", "usecase", + "usecases", + "userdefined", "vald", + "vald's", "valdbenchmarkjob", + "valdbenchmarkjobs", + "valdbenchmarkoperator", "valdbenchmarkoperatorrelease", + "valdbenchmarkoperatorreleases", "valdbenchmarkscenario", + "valdbenchmarkscenarios", + "valdchart", + "valdcli", "valdhelmoperatorrelease", - "valdhelmopratorreleases", + "valdhelmoperatorreleases", "valdmirrortarget", "valdmirrortargets", + "valdname", "valdrelease", + "valdreleases", + "vals", + "vankichi", + "vbjs", "vbor", + "vbors", + "vbss", "vdaas", "vdctl", + "vecs", "vectorizer", - "vectorizing", + "velit", + "veniam", + "versin", + "vfsgen", "vhor", + "vhors", + "vmap", + "vmdata", + "vmexe", + "vmhwm", + "vmlck", + "vmlib", + "vmpeak", + "vmpin", + "vmpte", + "vmrss", + "vmstk", + "vmswap", + "volumesnapshot", + "volumesnapshots", + "voluptate", + "voronoi", "vqueue", "vtproto", - "werr", + "warnd", + "warnf", + "warningf", + "warningln", + "wfci", "whitesource", + "wiretype", + "wlhf", + "workdir", + "worktree", + "wrapf", + "wrapperspb", + "xaxis", + "xeipuuv", + "xids", + "xlab", + "xxhash", + "xzvf", "yahoojapan", "yamlfmt", + "yaxes", + "yaxis", + "ykadowak", + "yukawa", + "yusuke", + "zapr", + "zchee", + "zdtd", + "zeebo", + "zerolog", + "zoneinfo", "zstd" ], - "ignoreWords": [ - "CMYK", - "SHOGO", - "TECHNOTE", - "agentd", - "benchmarkd", - "conflint", - "sidecard" - ], - "dictionaries": [ - "softwareTerms", - "misc", - "companies", - "typescript", - "node", - "html", - "css", - "fonts", - "filetypes", - "npm" - ], - "ignorePaths": [ - "**/*.ai", - "**/*.drawio", - "**/*.hdf5", - "**/*.key", - "**/*.lock", - "**/*.log", - "**/*.md5", - "**/*.pack", - "**/*.pdf", - "**/*.pem", - "**/*.png", - "**/*.sum", - "**/*.svg", - "**/.git/objects/**", - "**/cmd/agent/core/faiss/faiss", - "**/cmd/agent/core/ngt/ngt", - "**/cmd/agent/sidecar/sidecar", - "**/cmd/discoverer/k8s/k8s", - "**/cmd/gateway/filter/filter", - "**/cmd/gateway/lb/lb", - "**/cmd/gateway/mirror/mirror", - "**/cmd/index/job/correction/correction", - "**/cmd/index/job/creation/creation", - "**/cmd/index/job/readreplica/rotate/rotate", - "**/cmd/index/job/save/save", - "**/cmd/manager/index/index", - "**/internal/core/algorithm/ngt/assets/index", - "**/internal/test/data/agent/ngt/validIndex" - ] + "ignoreWordsMap": { + ".all-contributorsrc": [ + "Funakoshi", + "Grimaud", + "Hiroto", + "Hrichik", + "Kadowaki", + "Kato", + "Katz", + "Kiichiro", + "Koichi", + "Kosuke", + "Mazumder", + "Morimoto", + "Okamura", + "Rintaro", + "Shiraishi", + "Siyuan", + "YUKAWA", + "Yusuke", + "aknishid", + "ando", + "datelier", + "dotdc", + "hrichiksite", + "junsei", + "kevindiu", + "liusy", + "pgrimaud", + "taisuou", + "takuyaymd", + "thedrow", + "ykadowak", + "zchee" + ], + ".commit_template": [ + "bento", + "tada" + ], + ".devcontainer/devcontainer.json": [ + "PTRACE", + "commandhistory", + "seccomp", + "zshhistory" + ], + ".devcontainer/postAttachCommand.sh": [ + "commandhistory" + ], + ".fossa.yml": [ + "vdctl" + ], + ".git/hooks/applypatch-msg.sample": [ + "commitmsg" + ], + ".git/hooks/fsmonitor-watchman.sample": [ + "CHLD", + "binmode", + "clockid", + "msys" + ], + ".git/hooks/pre-commit.sample": [ + "allownonascii" + ], + ".git/hooks/pre-rebase.sample": [ + "Hamano", + "Junio", + "oneline" + ], + ".git/hooks/pre-receive.sample": [ + "echoback" + ], + ".git/hooks/push-to-checkout.sample": [ + "behaviour" + ], + ".git/hooks/sendemail-validate.sample": [ + "SENDEMAIL", + "Worktree", + "sendemail", + "worktree" + ], + ".git/hooks/update.sample": [ + "allowdeletetag", + "allowmodifytag", + "allowunannotated", + "newrev", + "oldrev", + "projectdesc" + ], + ".gitattributes": [ + "contributorsrc" + ], + ".gitfiles": [ + "CMYK", + "PROTOBUF", + "SHOGO", + "SOFTPROPS", + "TECHNOTE", + "accesslog", + "agentd", + "benchmarkd", + "brandguidelines", + "clusterrolebinding", + "conflint", + "contributorsrc", + "conv", + "darkgray", + "getstarted", + "gitfiles", + "gongt", + "helmignore", + "kosarak", + "kustomization", + "lycorp", + "multicluster", + "networkpolicy", + "nytimes", + "priorityclass", + "promtail", + "serviceaccount", + "sidecard", + "testdata", + "textlintrc", + "tmpl", + "valdmirrortarget", + "vdctl", + "whitesource" + ], + ".github/actions/docker-build/action.yaml": [ + "opencontainers" + ], + ".github/actions/notify-slack/action.yaml": [ + "technote" + ], + ".github/chatops_commands.md": [ + "bento" + ], + ".github/chatops_permissions.yaml": [ + "datelier", + "kevindiu" + ], + ".github/conflint.yaml": [ + "kubeval" + ], + ".github/dependabot.yml": [ + "gomod" + ], + ".github/helm/values/values-agent-sidecar.yaml": [ + "ACCESSKEY", + "SECRETKEY" + ], + ".github/helm/values/values-chaos.yaml": [ + "serversscheme" + ], + ".github/helm/values/values-profile.yaml": [ + "GOMAXPROCS" + ], + ".github/helm/values/values-readreplica.yaml": [ + "snapclass" + ], + ".github/workflows/_docker-image-scan.yaml": [ + "imagename", + "opencontainers" + ], + ".github/workflows/_docker-image.yaml": [ + "DOCKERHUB", + "buildkitd", + "stargz" + ], + ".github/workflows/backport.yml": [ + "startswith" + ], + ".github/workflows/build-binaries.yml": [ + "shogo" + ], + ".github/workflows/chatops.yml": [ + "gentest" + ], + ".github/workflows/detect-internal-config-changes.yml": [ + "INTCFG", + "interal" + ], + ".github/workflows/dockers-gateway-mirror-image.yaml": [ + "nirror" + ], + ".github/workflows/e2e-chaos.yaml": [ + "clusterwide" + ], + ".github/workflows/e2e-max-dim.yml": [ + "readlink" + ], + ".github/workflows/e2e-profiling.yml": [ + "threadcreate" + ], + ".github/workflows/fossa.yml": [ + "urllib" + ], + ".github/workflows/labeler.yml": [ + "shortstat" + ], + ".github/workflows/release.yml": [ + "goproxy", + "softprops" + ], + ".github/workflows/reviewdog-hadolint.yml": [ + "Dockerfiles" + ], + ".github/workflows/reviewdog-k8s.yml": [ + "CONFLINT", + "conflint", + "kubeval" + ], + ".github/workflows/reviewdog-markdown.yml": [ + "testlint" + ], + ".github/workflows/test-hack.yml": [ + "notests", + "smallscreen" + ], + ".github/workflows/unit-test.yaml": [ + "notests", + "smallscreen" + ], + ".gitignore": [ + "MSVC", + "dylib", + "nvim", + "nvimlog", + "rustc", + "rustfmt" + ], + ".golangci.yml": [ + "asasalint", + "asciicheck", + "bidichk", + "bodyclose", + "contextcheck", + "copylocks", + "cyclop", + "decorder", + "depguard", + "dupl", + "dupword", + "durationcheck", + "errcheck", + "errchkjson", + "errname", + "errorlint", + "execinquery", + "exhaustruct", + "exportloopref", + "forbidigo", + "forcetypeassert", + "ginkgolinter", + "gocheckcompilerdirectives", + "gochecknoglobals", + "gochecknoinits", + "gocognit", + "goconst", + "gocritic", + "gocyclo", + "godox", + "gofmt", + "goheader", + "gomoddirectives", + "gomodguard", + "goprintffuncname", + "gosec", + "gosimple", + "gosmopolitan", + "govet", + "importas", + "ineffassign", + "interfacebloat", + "ireturn", + "loggercheck", + "logrlint", + "makezero", + "megacheck", + "musttag", + "nakedret", + "nestif", + "nilnil", + "nlreturn", + "nolintlint", + "nonamedreturns", + "nosprintfhostport", + "paralleltest", + "prealloc", + "predeclared", + "promlinter", + "rowserrcheck", + "sqlclosecheck", + "staticcheck", + "stylecheck", + "testableexamples", + "testpackage", + "thelper", + "tparallel", + "unconvert", + "unparam", + "usestdlibvars", + "vetshadow", + "wastedassign", + "wrapcheck", + "wslissues" + ], + ".prh.yaml": [ + "Burstable", + "Flamegraph", + "besteffort", + "burstable", + "documentaion", + "flamegraph", + "valdcli" + ], + ".textlintrc": [ + "idrequest", + "mevie", + "rerank", + "sptag", + "subtest", + "vektor" + ], + "CHANGELOG.md": [ + "CFLAGS", + "CXXFLAGS", + "Cellebration", + "Dockerfiles", + "Metas", + "Migratation", + "OSDK", + "Stackdriver", + "Tutotial", + "alogrithm", + "ando", + "apiversion", + "bento", + "bidi", + "bulkinsert", + "cass", + "cheking", + "continous", + "conv", + "createindex", + "deeepsource", + "depentency", + "devcontiner", + "dotdc", + "errorgroup", + "exection", + "exhaustruct", + "exsiting", + "gache's", + "gorountine", + "hrichiksite", + "informations", + "iocopy", + "junsei", + "libquadmath", + "lincense", + "liusy", + "makr", + "malloc", + "minnum", + "multiplatforms", + "nvimlog", + "osdk", + "pacakge", + "pacicked", + "pbdocs", + "performace", + "priorityclasses", + "savedmodel", + "slowloris", + "sptag", + "stackdriver", + "tada", + "takuyaymd", + "tensorlfow", + "tset", + "unkeyed", + "unneccessary", + "valdcli", + "vcache", + "vqueue's", + "workdir", + "yamls", + "ykadowak", + "zchee" + ], + "CONTRIBUTING.md": [ + "Firstname", + "Lastname", + "implmentes", + "newfeature" + ], + "Makefile": [ + "BLAS", + "CRORG", + "DBLA", + "DBUILD", + "DCMAKE", + "DFAISS", + "EXTLDFLAGS", + "GHCRORG", + "GOCACHE", + "GOPROXY", + "MAKELISTS", + "NPROCESSORS", + "NUMPANES", + "ONLN", + "Ofast", + "PBDOCS", + "PBGOS", + "PROTOBUF", + "PROTODIRS", + "PROTOS", + "RLENGTH", + "RSTART", + "STDDEV", + "armv", + "copress", + "crlfmt", + "dockerfiles", + "fmerge", + "fopenmp", + "funroll", + "gitfiles", + "gsub", + "laec", + "lgfortran", + "lhdf", + "libfaiss", + "llapack", + "lopenblas", + "lstdc", + "mtune", + "ncpu", + "nproc", + "pthread", + "relro", + "strictgoimports", + "toplevel" + ], + "Makefile.d/bench.mk": [ + "benchmem", + "cpuprofile", + "memprofile", + "nvim" + ], + "Makefile.d/build.mk": [ + "EXTLDFLAGS", + "linkmode", + "popd", + "pushd" + ], + "Makefile.d/dependencies.mk": [ + "GOCACHE", + "PROTOBUF", + "modcache", + "testcache" + ], + "Makefile.d/docker.mk": [ + "CRORG", + "GHCRORG", + "buildcache", + "mediatypes", + "npmjs" + ], + "Makefile.d/e2e.mk": [ + "ECRUD" + ], + "Makefile.d/functions.mk": [ + "APIV", + "PBGOS", + "buildid", + "extldflags", + "modcacherw", + "netgo", + "osusergo", + "trimpath" + ], + "Makefile.d/helm.mk": [ + "valdmirrortarget", + "xzvf" + ], + "Makefile.d/k3d.mk": [ + "loadbalancer", + "storageclass" + ], + "Makefile.d/k8s.mk": [ + "CRORG", + "cainjector", + "jaegertracing", + "operatorusing", + "promtail", + "serrver" + ], + "Makefile.d/kind.mk": [ + "conntrack", + "netfilter" + ], + "Makefile.d/minikube.mk": [ + "hostpath", + "storageclass" + ], + "Makefile.d/proto.mk": [ + "PROTOS", + "protobufs" + ], + "Makefile.d/test.mk": [ + "covermode", + "coverprofile", + "cweill", + "gotesttools", + "mfridman", + "notests", + "showteststatus" + ], + "Makefile.d/tools.mk": [ + "DBUILD", + "DCMAKE", + "DHDF", + "DZLIB", + "busa", + "crlfmt", + "fatih", + "gomodifytags", + "goplay", + "haya", + "honnef", + "josharian", + "libz", + "momotaro", + "mvdan", + "segmentio", + "staticcheck", + "strictgoimports", + "tlsv", + "xzvf" + ], + "README.md": [ + "Codacy", + "Funakoshi", + "Grimaud", + "Hiroto", + "Hrichik", + "Kadowaki", + "Kato", + "Katz", + "Kiichiro", + "Koichi", + "Kosuke", + "Mazumder", + "Morimoto", + "Okamura", + "Rintaro", + "Shiraishi", + "Siyuan", + "YUKAWA", + "Yusuke", + "aknishid", + "ando", + "datelier", + "junsei", + "kevindiu", + "liusy", + "lycorp", + "srcset", + "taisuou", + "takuyaymd", + "thedrow", + "zchee" + ], + "apis/docs/v1/docs.md": [ + "Bignum", + "Fixnum", + "STOCKOUT", + "hasn", + "sfixed", + "sint" + ], + "apis/grpc/v1/payload/payload.pb.go": [ + "wrapperspb" + ], + "apis/grpc/v1/payload/payload.pb.json.go": [ + "protojson" + ], + "apis/grpc/v1/payload/payload_vtproto.pb.go": [ + "Indexmapkey", + "Indexmapvalue", + "Lenmapkey", + "Lenmapvalue", + "mapkey", + "mapvalue", + "postmsg", + "protohelpers", + "vtmsg", + "vtpb", + "wiretype", + "wrapperspb" + ], + "apis/grpc/v1/rpc/errdetails/error_details.pb.go": [ + "STOCKOUT", + "durationpb" + ], + "apis/grpc/v1/rpc/errdetails/error_details.pb.json.go": [ + "protojson" + ], + "apis/grpc/v1/rpc/errdetails/error_details_vtproto.pb.go": [ + "Indexmapkey", + "Indexmapvalue", + "Lenmapkey", + "Lenmapvalue", + "durationpb", + "mapkey", + "mapvalue", + "protohelpers", + "wiretype" + ], + "apis/proto/v1/agent/core/agent.proto": [ + "createandsave" + ], + "apis/proto/v1/payload/payload.proto": [ + "objc" + ], + "apis/proto/v1/rpc/errdetails/error_details.proto": [ + "STOCKOUT", + "objc" + ], + "apis/swagger/v1/agent/core/agent.swagger.json": [ + "createandsave" + ], + "assets/test/templates/common/fill.tmpl": [ + "uintptr" + ], + "assets/test/templates/common/function.tmpl": [ + "Subtests" + ], + "assets/test/templates/option/function.tmpl": [ + "Subtests" + ], + "buf.gen.yaml": [ + "mfridman", + "neoeinstein", + "openapiv", + "pseudomuto" + ], + "charts/vald-benchmark-operator/crds/valdbenchmarkjob.yaml": [ + "vbjs" + ], + "charts/vald-benchmark-operator/crds/valdbenchmarkoperatorrelease.yaml": [ + "valdbenchmarkoperator", + "valdbenchmarkoperatorreleases", + "vbor", + "vbors" + ], + "charts/vald-benchmark-operator/crds/valdbenchmarkscenario.yaml": [ + "vbss" + ], + "charts/vald-benchmark-operator/templates/clusterrole.yaml": [ + "deletecollection" + ], + "charts/vald-helm-operator/README.md": [ + "readyz" + ], + "charts/vald-helm-operator/crds/valdhelmoperatorrelease.yaml": [ + "vhors" + ], + "charts/vald-helm-operator/templates/clusterrole.yaml": [ + "clusterrolebindings", + "clusterroles", + "customresourcedefinitions", + "horizontalpodautoscalers", + "networkpolicies", + "persistentvolumeclaims", + "poddisruptionbudgets", + "priorityclasses", + "serviceaccounts", + "statefulsets" + ], + "charts/vald-helm-operator/values.yaml": [ + "readyz" + ], + "charts/vald-readreplica/Chart.yaml": [ + "ykadowak" + ], + "charts/vald-readreplica/templates/deployment.yaml": [ + "valdchart", + "valdname" + ], + "charts/vald-readreplica/templates/hpa.yaml": [ + "valdchart", + "valdname" + ], + "charts/vald-readreplica/templates/svc.yaml": [ + "valdchart", + "valdname" + ], + "charts/vald/README.md": [ + "goroutines" + ], + "charts/vald/crds/valdmirrortarget.yaml": [ + "valdmirrortarget", + "valdmirrortargets", + "vmts" + ], + "charts/vald/templates/_helpers.tpl": [ + "envkey", + "rsslimit", + "vszlimit" + ], + "charts/vald/templates/gateway/mirror/clusterrole.yaml": [ + "valdmirrortargets" + ], + "charts/vald/templates/index/job/readreplica/rotate/clusterrole.yaml": [ + "persistentvolumeclaims" + ], + "charts/vald/templates/index/job/readreplica/rotate/configmap.yaml": [ + "envkey" + ], + "charts/vald/values.schema.json": [ + "goroutines" + ], + "charts/vald/values.yaml": [ + "goroutines" + ], + "cmd/tools/cli/benchmark/core/main.go": [ + "pfile", + "vmdata", + "vmexe", + "vmlib", + "vmlock", + "vmpin", + "vmpte", + "vmstack", + "vmswap" + ], + "dockers/binfmt/Dockerfile": [ + "tonistiigi" + ], + "dockers/ci/base/Dockerfile": [ + "graphviz" + ], + "dockers/ci/base/README.md": [ + "titile" + ], + "dockers/dev/Dockerfile": [ + "gomodifytags", + "graphviz", + "staticcheck" + ], + "docs/api/build_proto.md": [ + "chrono", + "nanos", + "protos", + "rustc" + ], + "docs/contributing/coding-style.md": [ + "Roundtripper", + "Structs", + "crlfmt", + "httputil", + "ioutil", + "structs", + "subtests" + ], + "docs/overview/about-vald.md": [ + "rebalancing", + "rerank" + ], + "docs/overview/component/agent.md": [ + "verctors" + ], + "docs/overview/component/discoverer.md": [ + "nodeby" + ], + "docs/performance/continuous-benchmark.md": [ + "vbor" + ], + "docs/performance/loadtest.md": [ + "GOMAXPROCS", + "maxprocs", + "streaminsert" + ], + "docs/tutorial/get-started-with-faiss-agent.md": [ + "cvspq", + "jrnlw" + ], + "docs/tutorial/get-started.md": [ + "cvspq", + "getstarted", + "jrnlw", + "loadbalancer" + ], + "docs/tutorial/vald-agent-standalone-on-docker.md": [ + "GOMAXPROCS", + "maxprocs" + ], + "docs/tutorial/vald-multicluster-on-k8s.md": [ + "brbsp", + "dnxbb", + "ghlpx", + "gzcr", + "hbklj", + "kgrdf", + "multicluster", + "vjbqx", + "vlmpg", + "wtlcv", + "xmws" + ], + "docs/usecase/usage-example.md": [ + "vectorizing" + ], + "docs/user-guides/backup-configuration.md": [ + "ACCESSS" + ], + "docs/user-guides/capacity-planning.md": [ + "Burstable" + ], + "docs/user-guides/client-api-config.md": [ + "Milli", + "achive", + "rerank" + ], + "docs/user-guides/cluster-role-binding.md": [ + "clusterrolebinding", + "finalizers", + "retrive", + "valdmirrortargets" + ], + "docs/user-guides/deployment.md": [ + "finalizers", + "valdhelmopratorreleases" + ], + "example/helm/values-standalone-agent-ngt.yaml": [ + "mnist's" + ], + "example/helm/values-with-pyroscope.yaml": [ + "serversscheme" + ], + "example/helm/values.yaml": [ + "Agnet", + "mnist's", + "serversscheme" + ], + "example/manifest/scylla/configmap.yaml": [ + "initdb" + ], + "example/manifest/scylla/job.yaml": [ + "cqlsh", + "initdb" + ], + "go.mod": [ + "adal", + "afero", + "ajstarks", + "amqp", + "ansiterm", + "antihax", + "appengine", + "armon", + "astcopy", + "astequal", + "autorest", + "azcore", + "azidentity", + "benbjohnson", + "beorn", + "blackfriday", + "bmizerany", + "boombuler", + "buger", + "bytefmt", + "campoy", + "cenkalti", + "cespare", + "chunkreader", + "chzyer", + "cloudfoundry", + "cloudsql", + "cmdflag", + "colorstring", + "configsources", + "cpuguy", + "cpuid", + "creack", + "davecgh", + "dbus", + "dejavu", + "demangle", + "denisenkom", + "devigned", + "dgryski", + "difflib", + "diskv", + "dnaeon", + "easyjson", + "embedmd", + "emicklei", + "errcheck", + "evanphx", + "eventstream", + "fastuuid", + "felixge", + "fgprof", + "filippo", + "firestore", + "flowrate", + "fogleman", + "fortytw", + "fpdf", + "frankban", + "freetype", + "glfw", + "goautoneg", + "gobwas", + "godbus", + "godebug", + "godeltaprof", + "gofpdf", + "gofpdi", + "gofrs", + "gofuzz", + "gogrep", + "gojsonpointer", + "gojsonreference", + "gojsonschema", + "gomega", + "gomodules", + "gonic", + "gostub", + "gotool", + "gover", + "gregjones", + "groupcache", + "grpcreplay", + "hailocab", + "hanwen", + "honnef", + "httpcache", + "httpfs", + "httphead", + "httpreplay", + "httpsnoop", + "iancoleman", + "ianlancetaylor", + "imdario", + "imds", + "inconshreveable", + "isatty", + "jackc", + "jessevdk", + "jmespath", + "jmoiron", + "joho", + "josharian", + "jsonparser", + "jsonpointer", + "jsonreference", + "jstemmer", + "kisielk", + "kyaml", + "kylelemons", + "leaktest", + "leodido", + "liggitt", + "logex", + "logfmt", + "logr", + "lucasb", + "mailru", + "mattn", + "matttproud", + "mergo", + "mitchellh", + "modocache", + "monochromegane", + "montanaflynn", + "mountinfo", + "mssqldb", + "munnerz", + "nhooyr", + "niemeyer", + "nxadm", + "objx", + "ocsql", + "onsi", + "otelhttp", + "otlpmetric", + "otlpmetricgrpc", + "otlptracegrpc", + "peterbourgon", + "pflag", + "pgio", + "pgmock", + "pgpassfile", + "pgproto", + "pgservicefile", + "pgtype", + "phpdave", + "pierrec", + "pmezard", + "prashantv", + "progressbar", + "quicktest", + "ratelimit", + "replayers", + "rogpeppe", + "russross", + "ruudk", + "sbinet", + "schollz", + "secretmanager", + "sergi", + "shlex", + "shopspring", + "shurcoo", + "sirupsen", + "spdystream", + "sqlexp", + "sqlmock", + "sqlx", + "starlark", + "stdinfo", + "stdr", + "stix", + "stoewer", + "strcase", + "strparse", + "tabwriter", + "toolsmith", + "treeprint", + "typeparams", + "udpa", + "ugorji", + "vfsgen", + "xeipuuv", + "xlab", + "xxhash", + "zapr" + ], + "hack/benchmark/assets/x1b/loader.go": [ + "fname" + ], + "hack/benchmark/assets/x1b/loader_test.go": [ + "fname" + ], + "hack/benchmark/internal/db/nosql/cassandra/cassandra_test.go": [ + "metas" + ], + "hack/benchmark/internal/db/nosql/cassandra/testdata.json": [ + "Adipisicing", + "Aliqua", + "Aliquip", + "Amet", + "Aute", + "Cillum", + "Commodo", + "Consequat", + "Cupidatat", + "Deserunt", + "Dolore", + "Duis", + "Eiusmod", + "Elit", + "Enim", + "Excepteur", + "Fugiat", + "Incididunt", + "Irure", + "Labore", + "Laboris", + "Laborum", + "Mollit", + "Nostrud", + "Nulla", + "Occaecat", + "Officia", + "Pariatur", + "Proident", + "Quis", + "Reprehenderit", + "Sint", + "Sunt", + "Tempor", + "Ullamco", + "Velit", + "Veniam", + "Voluptate", + "adipisicing", + "aliqua", + "aliquip", + "amet", + "aute", + "cillum", + "commodo", + "consequat", + "cupidatat", + "deserunt", + "dolore", + "duis", + "eiusmod", + "elit", + "enim", + "excepteur", + "fugiat", + "incididunt", + "irure", + "labore", + "laboris", + "laborum", + "mollit", + "nostrud", + "nulla", + "occaecat", + "officia", + "pariatur", + "proident", + "quis", + "reprehenderit", + "sint", + "sunt", + "tempor", + "ullamco", + "velit", + "veniam", + "voluptate" + ], + "hack/benchmark/internal/starter/agent/core/ngt/option.go": [ + "dtype", + "otype" + ], + "hack/benchmark/src/singleflight/singleflight_bench_test.go": [ + "durs", + "resultsmap", + "singlefligh", + "stdsingleflight" + ], + "hack/docker/gen/main.go": [ + "Inernal", + "TARGETARCH", + "TARGETOS", + "WORKDIR", + "Workdir", + "epkg", + "gomodifytags", + "graphviz", + "tmpl", + "tonistiigi" + ], + "hack/go.mod.default": [ + "adal", + "afero", + "ajstarks", + "amqp", + "antihax", + "appengine", + "armon", + "astcopy", + "astequal", + "autorest", + "azcore", + "azidentity", + "benbjohnson", + "beorn", + "blackfriday", + "bmizerany", + "boombuler", + "buger", + "bytefmt", + "cenkalti", + "cespare", + "chunkreader", + "chzyer", + "cloudfoundry", + "cloudsql", + "cmdflag", + "colorstring", + "configsources", + "cpuguy", + "cpuid", + "creack", + "davecgh", + "dbus", + "dejavu", + "demangle", + "denisenkom", + "devigned", + "dgryski", + "difflib", + "diskv", + "dnaeon", + "easyjson", + "emicklei", + "errcheck", + "evanphx", + "eventstream", + "fastuuid", + "firestore", + "fogleman", + "fortytw", + "fpdf", + "frankban", + "freetype", + "glfw", + "goautoneg", + "gobwas", + "godbus", + "godebug", + "godeltaprof", + "gofpdf", + "gofpdi", + "gofrs", + "gofuzz", + "gogrep", + "gojsonpointer", + "gojsonreference", + "gojsonschema", + "gomega", + "gomodules", + "gonic", + "gostub", + "gotool", + "gover", + "gregjones", + "groupcache", + "grpcreplay", + "hailocab", + "hanwen", + "honnef", + "httpcache", + "httpfs", + "httphead", + "httpreplay", + "iancoleman", + "ianlancetaylor", + "imds", + "inconshreveable", + "isatty", + "jackc", + "jessevdk", + "jmespath", + "jmoiron", + "joho", + "josharian", + "jsonparser", + "jsonpointer", + "jsonreference", + "jstemmer", + "kisielk", + "kylelemons", + "leaktest", + "leodido", + "liggitt", + "logex", + "logfmt", + "logr", + "lucasb", + "mailru", + "mattn", + "matttproud", + "mitchellh", + "modocache", + "monochromegane", + "montanaflynn", + "mountinfo", + "mssqldb", + "munnerz", + "nhooyr", + "niemeyer", + "nxadm", + "objx", + "ocsql", + "onsi", + "otlpmetric", + "otlpmetricgrpc", + "otlptracegrpc", + "peterbourgon", + "pflag", + "pgio", + "pgmock", + "pgpassfile", + "pgproto", + "pgservicefile", + "pgtype", + "phpdave", + "pierrec", + "pmezard", + "prashantv", + "progressbar", + "quicktest", + "replayers", + "rogpeppe", + "russross", + "ruudk", + "sbinet", + "schollz", + "secretmanager", + "sergi", + "shlex", + "shopspring", + "shurcoo", + "sirupsen", + "spdystream", + "sqlexp", + "sqlmock", + "sqlx", + "starlark", + "stdinfo", + "stdr", + "stix", + "stoewer", + "strcase", + "strparse", + "tabwriter", + "toolsmith", + "treeprint", + "typeparams", + "udpa", + "ugorji", + "vfsgen", + "xeipuuv", + "xlab", + "xxhash", + "zapr" + ], + "hack/gorules/rules_test.go": [ + "analysistest" + ], + "hack/gorules/testdata/tests.go": [ + "Fmts", + "newname" + ], + "hack/license/gen/main.go": [ + "Pipefile", + "contributorsrc", + "dirwalk", + "gitmodules", + "helmignore", + "tmpl", + "webp", + "whitesource" + ], + "hack/tools/metrics/main.go": [ + "lucasb", + "vgsvg" + ], + "internal/backoff/backoff_test.go": [ + "timelimit" + ], + "internal/circuitbreaker/breaker_test.go": [ + "resetted" + ], + "internal/client/v1/client/client.go": [ + "Upsertor" + ], + "internal/client/v1/client/discoverer/discover_test.go": [ + "copylocks", + "govet" + ], + "internal/compress/gzip_option_test.go": [ + "zdtd" + ], + "internal/compress/lz4/lz4.go": [ + "pierrec" + ], + "internal/compress/zstd_option_test.go": [ + "zdtd" + ], + "internal/compress/zstd_test.go": [ + "decom", + "vecotr" + ], + "internal/config/backup_test.go": [ + "healthcheck" + ], + "internal/config/blob.go": [ + "storaget" + ], + "internal/config/blob_test.go": [ + "CLOUDSTORAGECONFIG" + ], + "internal/config/cassandra.go": [ + "TLSCA" + ], + "internal/config/cassandra_test.go": [ + "localserial" + ], + "internal/config/compress_test.go": [ + "COMPRESSCORE", + "COMPRESSORREGISTERER" + ], + "internal/config/config.go": [ + "dnum", + "rdst", + "snum", + "vdst" + ], + "internal/config/config_test.go": [ + "GETACTUALVALUE", + "GETACTUALVALUES", + "GLOBALCONFIG", + "fname" + ], + "internal/config/faiss.go": [ + "Voronoi", + "subquantizers", + "subvector" + ], + "internal/config/filter_test.go": [ + "sufix" + ], + "internal/config/gateway_test.go": [ + "bmanager", + "efilter", + "ireplica" + ], + "internal/config/grpc.go": [ + "Dail" + ], + "internal/config/grpc_test.go": [ + "DIALOPTION", + "GRPCCLIENT", + "GRPCCLIENTKEEPALIVE", + "healthcheck" + ], + "internal/config/observability_test.go": [ + "servicename" + ], + "internal/config/redis_test.go": [ + "Timelimit" + ], + "internal/config/server_test.go": [ + "GPRC", + "GRPCKEEPALIVE" + ], + "internal/config/sidecar_test.go": [ + "AGENTSIDECAR" + ], + "internal/conv/conv.go": [ + "Atobs" + ], + "internal/core/algorithm/faiss/Capi.cpp": [ + "IVFPQ", + "xids" + ], + "internal/core/algorithm/faiss/Capi.h": [ + "xids" + ], + "internal/core/algorithm/faiss/faiss.go": [ + "lfaiss", + "ntotal", + "strage", + "xids" + ], + "internal/core/algorithm/faiss/option.go": [ + "lfaiss" + ], + "internal/core/algorithm/ngt/Makefile": [ + "benchmem" + ], + "internal/core/algorithm/ngt/ngt.go": [ + "bulkinsert", + "bulkremove", + "cstats", + "lngt", + "ospace", + "stdlib" + ], + "internal/core/algorithm/ngt/ngt_test.go": [ + "bulkinsert", + "ospace" + ], + "internal/core/algorithm/ngt/option.go": [ + "dotp", + "dproduct", + "halffloat", + "innerp", + "iproduct", + "lngt", + "nang", + "nangle", + "ncos", + "ncosine", + "normalizedang", + "normalizedcos", + "sparsejac" + ], + "internal/core/algorithm/ngt/option_test.go": [ + "nang", + "ncos" + ], + "internal/db/kvs/bbolt/bbolt_test.go": [ + "testfunc" + ], + "internal/db/kvs/bbolt/option.go": [ + "Freelist" + ], + "internal/db/kvs/bbolt/option_test.go": [ + "Freelist" + ], + "internal/db/kvs/pogreb/options.go": [ + "deafult" + ], + "internal/db/kvs/pogreb/pogreb.go": [ + "deafult" + ], + "internal/db/kvs/redis/delete.go": [ + "Deleter" + ], + "internal/db/kvs/redis/hook.go": [ + "Cmder" + ], + "internal/db/kvs/redis/option_test.go": [ + "defult" + ], + "internal/db/kvs/redis/redis.go": [ + "Deleter", + "Pipeliner" + ], + "internal/db/kvs/redis/redis_mock.go": [ + "Cmder", + "Pipeliner" + ], + "internal/db/kvs/redis/redis_test.go": [ + "cslots", + "gotc" + ], + "internal/db/nosql/cassandra/cassandra.go": [ + "Queryx", + "cmps", + "configuation", + "wlhf" + ], + "internal/db/nosql/cassandra/cassandra_test.go": [ + "Debouncer", + "Queryx", + "cmps", + "dchf", + "selete", + "unavilable", + "wlhf" + ], + "internal/db/nosql/cassandra/delete.go": [ + "Deleter" + ], + "internal/db/nosql/cassandra/option.go": [ + "TLSCA", + "eachquorum", + "localone", + "localquorum", + "localserial" + ], + "internal/db/nosql/cassandra/option_test.go": [ + "TLSCA" + ], + "internal/db/rdb/mysql/mysql_test.go": [ + "insertbysql", + "loadcontext" + ], + "internal/db/rdb/mysql/option_test.go": [ + "valddb", + "valdmysql" + ], + "internal/db/storage/blob/cloudstorage/cloudstorage.go": [ + "iblob" + ], + "internal/db/storage/blob/cloudstorage/cloudstorage_test.go": [ + "iblob" + ], + "internal/db/storage/blob/cloudstorage/option.go": [ + "urlstr" + ], + "internal/db/storage/blob/s3/reader/reader_test.go": [ + "roop" + ], + "internal/db/storage/blob/s3/sdk/s3/s3manager/s3manager.go": [ + "mngr" + ], + "internal/db/storage/blob/s3/session/session_test.go": [ + "btop", + "forcepathstyle", + "httpclient", + "itop", + "maxretries" + ], + "internal/errors/benchmark.go": [ + "benchjob", + "benchscenario", + "tbenchjob", + "tbenchscenario" + ], + "internal/errors/cassandra.go": [ + "consistetncy", + "tcql" + ], + "internal/errors/cassandra_test.go": [ + "consistetncy", + "tcql" + ], + "internal/errors/circuitbreaker.go": [ + "errstr" + ], + "internal/errors/compressor.go": [ + "registerers" + ], + "internal/errors/compressor_test.go": [ + "leve", + "registerers" + ], + "internal/errors/errors_test.go": [ + "Unwarp", + "uncomparable", + "unwrapd" + ], + "internal/errors/file.go": [ + "fitos" + ], + "internal/errors/file_test.go": [ + "fitos" + ], + "internal/errors/lb.go": [ + "Insuffcient" + ], + "internal/errors/mysql_test.go": [ + "vaef" + ], + "internal/errors/redis.go": [ + "KVVK" + ], + "internal/errors/redis_test.go": [ + "KVVK" + ], + "internal/errors/vald_test.go": [ + "tvald" + ], + "internal/file/file_test.go": [ + "utiltest" + ], + "internal/info/info.go": [ + "procs", + "strs" + ], + "internal/k8s/client/client.go": [ + "applyconfigurations", + "applycorev", + "clientgoscheme", + "snapshotv", + "volumesnapshot" + ], + "internal/k8s/job/job.go": [ + "batchv" + ], + "internal/k8s/option.go": [ + "mertics" + ], + "internal/k8s/reconciler.go": [ + "mertics", + "mserver" + ], + "internal/k8s/reconciler_test.go": [ + "mertics" + ], + "internal/k8s/types.go": [ + "appsv", + "batchv", + "snapshotv", + "volumesnapshot" + ], + "internal/k8s/vald/benchmark/api/v1/job_types.go": [ + "deepcopy" + ], + "internal/k8s/vald/benchmark/api/v1/scenario_types.go": [ + "deepcopy" + ], + "internal/k8s/vald/mirror/api/v1/target_types.go": [ + "deepcopy" + ], + "internal/log/glg/glg.go": [ + "DEBG", + "dstr" + ], + "internal/log/glg/glg_test.go": [ + "DEBG" + ], + "internal/log/level/level.go": [ + "DEBG", + "ERRO", + "FATA" + ], + "internal/log/logger/iface.go": [ + "finalizer" + ], + "internal/log/logger/type.go": [ + "Atot" + ], + "internal/log/logger/type_test.go": [ + "Atot", + "ZEROL" + ], + "internal/log/nop/nop.go": [ + "finalizer" + ], + "internal/log/option.go": [ + "Atot" + ], + "internal/log/retry/retry_test.go": [ + "foramt", + "gotr", + "wantr" + ], + "internal/net/control/control.go": [ + "boolint" + ], + "internal/net/control/control_test.go": [ + "boolint" + ], + "internal/net/control/control_unix.go": [ + "uapi" + ], + "internal/net/dialer.go": [ + "nport", + "tconnectionstate", + "tder" + ], + "internal/net/dialer_test.go": [ + "Nums", + "copylocks", + "govet" + ], + "internal/net/grpc/client.go": [ + "gbackoff", + "parseable", + "rebalancing" + ], + "internal/net/grpc/client_test.go": [ + "gbackoff" + ], + "internal/net/grpc/errdetails/errdetails.go": [ + "iobjs" + ], + "internal/net/grpc/logger/logger.go": [ + "Errorln", + "Infoln", + "Warningf", + "Warningln", + "grpclog" + ], + "internal/net/grpc/logger/logger_test.go": [ + "Errorln", + "Infoln", + "Warningf", + "Warningln", + "grpclog" + ], + "internal/net/grpc/option.go": [ + "gbackoff", + "metricinterceptor", + "traceinterceptor" + ], + "internal/net/grpc/pool/pool.go": [ + "tdelay" + ], + "internal/net/grpc/proto/proto.go": [ + "protoiface" + ], + "internal/net/grpc/server_test.go": [ + "channelz" + ], + "internal/net/http/client/option.go": [ + "Alives", + "Keepalives" + ], + "internal/net/http/client/option_test.go": [ + "Alives", + "Keepalives" + ], + "internal/net/http/dump/dump_test.go": [ + "hoge" + ], + "internal/net/http/metrics/pprof.go": [ + "felixge", + "fgprof", + "godeltaprof", + "pyprof", + "threadcreate" + ], + "internal/net/http/middleware/timeout_test.go": [ + "extermemly" + ], + "internal/net/http/transport/roundtrip.go": [ + "roundtripper" + ], + "internal/net/net.go": [ + "hostport" + ], + "internal/net/net_test.go": [ + "hostport" + ], + "internal/observability/exporter/otlp/otlp.go": [ + "otlpmetric", + "otlpmetricgrpc", + "otlptracegrpc", + "semconv" + ], + "internal/observability/metrics/grpc/grpc.go": [ + "Desctiption" + ], + "internal/observability/metrics/mem/index/index.go": [ + "mstats" + ], + "internal/observability/metrics/mem/mem.go": [ + "Memstats", + "Shmem", + "buckhash", + "mcache", + "mspan", + "oinsts", + "shmem", + "toal", + "vmdata", + "vmexe", + "vmlck", + "vmlib", + "vmpin", + "vmpte", + "vmstk", + "vmswap" + ], + "internal/observability/metrics/mem/mem_test.go": [ + "Memstats" + ], + "internal/observability/trace/status.go": [ + "RPCGRPC", + "ocodes", + "semconv" + ], + "internal/params/params.go": [ + "commnad" + ], + "internal/runner/runner.go": [ + "maxprocs", + "mfunc", + "timelocation" + ], + "internal/safety/safety.go": [ + "revcover", + "runtimer" + ], + "internal/servers/option.go": [ + "strg" + ], + "internal/servers/option_test.go": [ + "gsrv", + "strg" + ], + "internal/servers/server/option.go": [ + "accesslog", + "accessloginterceptor", + "metricinterceptor", + "recoverinterceptor", + "traceinterceptor" + ], + "internal/servers/server/server_test.go": [ + "prestart" + ], + "internal/servers/servers_test.go": [ + "strg" + ], + "internal/strings/strings_benchmark_test.go": [ + "tstr" + ], + "internal/sync/errgroup/group_test.go": [ + "acquireings", + "goroutne" + ], + "internal/sync/semaphore/semaphore.go": [ + "cancelation" + ], + "internal/sync/semaphore/semaphore_example_test.go": [ + "Collatz", + "collatz", + "nonpositive" + ], + "internal/sync/semaphore/semaphore_test.go": [ + "Doesnt", + "unacquired" + ], + "internal/sync/singleflight/singleflight.go": [ + "chans", + "dups" + ], + "internal/sync/singleflight/singleflight_test.go": [ + "DOCHAN", + "unparam" + ], + "internal/test/data/hdf5/hdf5.go": [ + "Keepalives", + "Neighors" + ], + "internal/test/data/hdf5/option.go": [ + "dataname" + ], + "internal/test/data/vector/gen.go": [ + "irand" + ], + "internal/test/mock/grpc_testify_mock.go": [ + "losm", + "usecases" + ], + "internal/test/mock/k8s/client.go": [ + "crclient" + ], + "internal/timeutil/rate/rate.go": [ + "ratelimit" + ], + "internal/timeutil/rate/rate_test.go": [ + "ratelimit" + ], + "internal/timeutil/time_test.go": [ + "dummystring", + "hoge" + ], + "internal/unit/unit.go": [ + "bytefmt", + "cloudfoundry" + ], + "internal/version/version.go": [ + "curv" + ], + "internal/worker/worker_test.go": [ + "testname" + ], + "k8s/external/minio/deployment.yaml": [ + "ACCESSKEY", + "SECRETKEY" + ], + "k8s/external/minio/mb-job.yaml": [ + "ACCESSKEY", + "SECRETKEY" + ], + "k8s/metrics/grafana/dashboards/00-vald-cluster-overview.yaml": [ + "Misscheduled", + "Qxya", + "misscheduled" + ], + "k8s/metrics/grafana/dashboards/02-vald-discoverer.yaml": [ + "Jkemc", + "Versin" + ], + "k8s/metrics/grafana/dashboards/05-vald-index-manager.yaml": [ + "jowe" + ], + "k8s/metrics/grafana/dashboards/10-vald-benchmark-operator.yaml": [ + "Versin", + "fdewjfx", + "jkxz" + ], + "k8s/metrics/grafana/dashboards/99-vald-agent-memory.yaml": [ + "Memstats", + "buckhash", + "mcache", + "mspan", + "vmdata", + "vmexe", + "vmlck", + "vmlib", + "vmpin", + "vmpte", + "vmstk", + "vmswap" + ], + "k8s/metrics/jaeger/jaeger.yaml": [ + "jaegertracing" + ], + "k8s/metrics/loki/loki.yaml": [ + "boltdb", + "ingester", + "inmemory", + "kvstore", + "lifecycler" + ], + "k8s/metrics/loki/promtail.yaml": [ + "labelmap", + "promtail", + "varlibdockercontainers", + "varlog" + ], + "k8s/metrics/prometheus/configmap.yaml": [ + "cadvisor", + "labelmap" + ], + "k8s/metrics/pyroscope/README.md": [ + "mafests" + ], + "k8s/metrics/pyroscope/base/configmap.yaml": [ + "labelmap" + ], + "k8s/metrics/pyroscope/base/daemonset.yaml": [ + "ebpfspy" + ], + "k8s/metrics/pyroscope/base/kustomization.yaml": [ + "clusterrolebinding" + ], + "k8s/metrics/tempo/jaeger-agent.yaml": [ + "jaegertracing" + ], + "k8s/metrics/tempo/tempo.yaml": [ + "blocklist", + "ingester", + "inmemory", + "kvstore", + "lifecycler" + ], + "k8s/operator/helm/clusterrole.yaml": [ + "clusterrolebindings", + "clusterroles", + "customresourcedefinitions", + "horizontalpodautoscalers", + "networkpolicies", + "persistentvolumeclaims", + "poddisruptionbudgets", + "priorityclasses", + "serviceaccounts", + "statefulsets" + ], + "k8s/operator/helm/crds/valdhelmoperatorrelease.yaml": [ + "vhors" + ], + "k8s/operator/helm/operator.yaml": [ + "readyz" + ], + "k8s/tools/benchmark/job/clusterrolebinding.yaml": [ + "rolebinding" + ], + "k8s/tools/benchmark/job/serviceaccount.yaml": [ + "Versoin" + ], + "k8s/tools/benchmark/operator/clusterrole.yaml": [ + "deletecollection" + ], + "k8s/tools/benchmark/operator/crds/valdbenchmarkjob.yaml": [ + "vbjs" + ], + "k8s/tools/benchmark/operator/crds/valdbenchmarkoperatorrelease.yaml": [ + "valdbenchmarkoperator", + "valdbenchmarkoperatorreleases", + "vbor", + "vbors" + ], + "k8s/tools/benchmark/operator/crds/valdbenchmarkscenario.yaml": [ + "vbss" + ], + "pkg/agent/core/faiss/handler/grpc/search.go": [ + "createing" + ], + "pkg/agent/core/faiss/service/faiss.go": [ + "Voronoi", + "ntotal", + "saveindex", + "subquantizers", + "tpath", + "tvald" + ], + "pkg/agent/core/faiss/service/option.go": [ + "bdbs", + "brnd" + ], + "pkg/agent/core/faiss/usecase/agentd.go": [ + "faissmetrics" + ], + "pkg/agent/core/ngt/handler/grpc/flush.go": [ + "cnts" + ], + "pkg/agent/core/ngt/handler/grpc/index_test.go": [ + "exteneral" + ], + "pkg/agent/core/ngt/handler/grpc/insert.go": [ + "vmap" + ], + "pkg/agent/core/ngt/handler/grpc/insert_test.go": [ + "Testingcase", + "joind", + "nonexistid", + "pushinsert" + ], + "pkg/agent/core/ngt/handler/grpc/object_test.go": [ + "testfunc", + "tmock" + ], + "pkg/agent/core/ngt/handler/grpc/update.go": [ + "idis", + "vmap" + ], + "pkg/agent/core/ngt/handler/grpc/update_test.go": [ + "Testint" + ], + "pkg/agent/core/ngt/service/ngt.go": [ + "Nopvq", + "nkvs", + "nobic", + "nopvq", + "saveindex", + "toid", + "tvald" + ], + "pkg/agent/core/ngt/service/ngt_test.go": [ + "additionaldigits", + "kvald", + "metafile", + "nobic", + "nopvq", + "testfunc" + ], + "pkg/agent/core/ngt/service/option.go": [ + "bdbs", + "brnd" + ], + "pkg/agent/core/ngt/usecase/agentd.go": [ + "memmetrics", + "ngtmetrics" + ], + "pkg/agent/internal/vqueue/queue.go": [ + "uninserted" + ], + "pkg/agent/internal/vqueue/stateful_test.go": [ + "getvector" + ], + "pkg/agent/sidecar/service/restorer/restorer.go": [ + "Typeflag" + ], + "pkg/discoverer/k8s/handler/grpc/handler.go": [ + "ngroup", + "pgroup", + "sgroup" + ], + "pkg/discoverer/k8s/handler/grpc/handler_test.go": [ + "ngroup", + "pgroup", + "sgroup" + ], + "pkg/discoverer/k8s/service/discover.go": [ + "mnode", + "mpod", + "reconciation", + "svcsmap" + ], + "pkg/discoverer/k8s/service/discover_test.go": [ + "mnode", + "mpod" + ], + "pkg/discoverer/k8s/usecase/discovered.go": [ + "unbackupped" + ], + "pkg/gateway/lb/handler/grpc/aggregation.go": [ + "Insuffcient", + "fdist", + "fmax", + "timeoutage" + ], + "pkg/gateway/lb/handler/grpc/handler.go": [ + "cnts", + "indegrees", + "outdegrees" + ], + "pkg/gateway/lb/handler/grpc/handler_test.go": [ + "Cnts" + ], + "pkg/gateway/lb/handler/grpc/pairing_heap_test.go": [ + "gids" + ], + "pkg/gateway/lb/handler/grpc/search_benchmark_test.go": [ + "datas" + ], + "pkg/gateway/mirror/handler/grpc/handler_test.go": [ + "clientmock", + "cmap" + ], + "pkg/gateway/mirror/service/discovery.go": [ + "ctgt", + "ptgt" + ], + "pkg/gateway/mirror/service/discovery_option.go": [ + "datacenter" + ], + "pkg/gateway/mirror/service/mirror_test.go": [ + "grpcmock" + ], + "pkg/gateway/mirror/usecase/vald.go": [ + "mirrormetrics" + ], + "pkg/index/job/creation/service/indexer_test.go": [ + "clientmock", + "grpcmock" + ], + "pkg/index/job/save/service/indexer_test.go": [ + "clientmock", + "grpcmock" + ], + "pkg/manager/index/usecase/indexer.go": [ + "indexmetrics" + ], + "pkg/tools/benchmark/job/config/config.go": [ + "JOBNAME", + "JOBNAMESPACE" + ], + "pkg/tools/benchmark/job/service/insert.go": [ + "Prometeus" + ], + "pkg/tools/benchmark/job/service/job.go": [ + "Neighors", + "benchjob" + ], + "pkg/tools/benchmark/job/service/option.go": [ + "Concurency", + "bjns" + ], + "pkg/tools/benchmark/job/service/option_test.go": [ + "Concurency", + "bjns" + ], + "pkg/tools/benchmark/job/usecase/benchmarkd.go": [ + "Concurency", + "gcli", + "unbackupped", + "usecases", + "vcli" + ], + "pkg/tools/benchmark/operator/service/operator.go": [ + "Progation", + "benchjob", + "benchjobs", + "benchmarkjob", + "benchscenario", + "bjob", + "cbjl", + "cbsl", + "cjobs", + "rcticker", + "wating" + ], + "pkg/tools/benchmark/operator/service/operator_test.go": [ + "benchjobs", + "minsit", + "scneario" + ], + "pkg/tools/benchmark/operator/usecase/benchmarkd.go": [ + "benchmarkmetrics", + "unbackupped", + "usecases" + ], + "pkg/tools/cli/loadtest/assets/dataset.go": [ + "kosarak", + "nytimes" + ], + "pkg/tools/cli/loadtest/assets/hdf5_loader.go": [ + "dset", + "npoints" + ], + "pkg/tools/cli/loadtest/assets/hdf5_loader_test.go": [ + "dset", + "npoints" + ], + "pkg/tools/cli/loadtest/config/config.go": [ + "streaminsert" + ], + "rust/libs/ngt-rs/Cargo.toml": [ + "miette" + ], + "rust/libs/ngt-rs/build.rs": [ + "BFLOAT", + "DNGT", + "dylib", + "fopenmp", + "gomp", + "miette", + "rustc" + ], + "rust/libs/ngt-rs/src/input.cpp": [ + "cpath", + "ngtresults", + "vquery" + ], + "rust/libs/ngt-rs/src/lib.rs": [ + "repr" + ], + "rust/libs/observability/Cargo.toml": [ + "reqwest", + "scopeguard", + "serde" + ], + "rust/libs/observability/src/macros.rs": [ + "Updown" + ], + "rust/libs/proto/src/payload.v1.rs": [ + "repr" + ], + "tests/chaos/chart/README.md": [ + "kbps", + "minburst", + "peakrate" + ], + "tests/chaos/chart/templates/network/bandwidth.yaml": [ + "minburst", + "peakrate" + ], + "tests/chaos/chart/values.yaml": [ + "kbps", + "minburst", + "peakrate" + ], + "tests/e2e/crud/crud_test.go": [ + "ECRUD" + ], + "tests/e2e/kubernetes/client/client.go": [ + "Clientset", + "clientcmd", + "clientset" + ], + "tests/e2e/kubernetes/kubectl/kubectl.go": [ + "rollouts", + "subcmds" + ], + "tests/e2e/kubernetes/portforward/portforward.go": [ + "genericclioptions", + "portforwarder", + "spdy", + "upgrader" + ], + "tests/e2e/operation/stream.go": [ + "evalidator", + "svalidator" + ] + } } diff --git a/.gitfiles b/.gitfiles index 64f792a39c..bc3aad9d2b 100644 --- a/.gitfiles +++ b/.gitfiles @@ -1,18 +1,3 @@ -# -# Copyright (C) 2019-2024 vdaas.org vald team -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# You may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# .all-contributorsrc .commit_template .cspell.json @@ -140,7 +125,6 @@ Makefile Makefile.d/actions.mk Makefile.d/bench.mk Makefile.d/build.mk -Makefile.d/client.mk Makefile.d/dependencies.mk Makefile.d/docker.mk Makefile.d/e2e.mk @@ -1904,6 +1888,11 @@ rust/libs/ngt-rs/src/input.h rust/libs/ngt-rs/src/lib.rs rust/libs/ngt/Cargo.toml rust/libs/ngt/src/lib.rs +rust/libs/observability/Cargo.toml +rust/libs/observability/src/config.rs +rust/libs/observability/src/lib.rs +rust/libs/observability/src/macros.rs +rust/libs/observability/src/observability.rs rust/libs/proto/Cargo.toml rust/libs/proto/src/core.v1.tonic.rs rust/libs/proto/src/discoverer.v1.tonic.rs @@ -1965,7 +1954,6 @@ versions/PROTOBUF_VERSION versions/REVIEWDOG_VERSION versions/RUST_VERSION versions/TELEPRESENCE_VERSION -versions/VALDCLI_VERSION versions/VALD_VERSION versions/YQ_VERSION versions/ZLIB_VERSION diff --git a/.github/helm/values/values-correction.yaml b/.github/helm/values/values-correction.yaml index 888931ca6f..0632c3d2f7 100644 --- a/.github/helm/values/values-correction.yaml +++ b/.github/helm/values/values-correction.yaml @@ -16,7 +16,7 @@ defaults: logging: - level: info + level: debug networkPolicy: enabled: true gateway: diff --git a/.github/workflows/dockers-benchmark-job-image.yml b/.github/workflows/dockers-benchmark-job-image.yml index 2d59b4356c..7b05be9b09 100644 --- a/.github/workflows/dockers-benchmark-job-image.yml +++ b/.github/workflows/dockers-benchmark-job-image.yml @@ -27,7 +27,7 @@ on: paths: - ".github/actions/docker-build/action.yaml" - ".github/workflows/_docker-image.yaml" - - ".github/workflows/dockers-benchmak-job-image.yml" + - ".github/workflows/dockers-benchmark-job-image.yml" - "go.mod" - "go.sum" - "internal/**" @@ -44,7 +44,7 @@ on: paths: - ".github/actions/docker-build/action.yaml" - ".github/workflows/_docker-image.yaml" - - ".github/workflows/dockers-benchmak-job-image.yml" + - ".github/workflows/dockers-benchmark-job-image.yml" - "go.mod" - "go.sum" - "internal/**" diff --git a/.github/workflows/dockers-benchmark-operator-image.yaml b/.github/workflows/dockers-benchmark-operator-image.yaml index 2cc23d85b3..8509ed2545 100644 --- a/.github/workflows/dockers-benchmark-operator-image.yaml +++ b/.github/workflows/dockers-benchmark-operator-image.yaml @@ -27,7 +27,7 @@ on: paths: - ".github/actions/docker-build/action.yaml" - ".github/workflows/_docker-image.yaml" - - ".github/workflows/dockers-benchmak-operator-image.yml" + - ".github/workflows/dockers-benchmark-operator-image.yml" - "go.mod" - "go.sum" - "internal/**" @@ -44,7 +44,7 @@ on: paths: - ".github/actions/docker-build/action.yaml" - ".github/workflows/_docker-image.yaml" - - ".github/workflows/dockers-benchmak-operator-image.yml" + - ".github/workflows/dockers-benchmark-operator-image.yml" - "go.mod" - "go.sum" - "internal/**" diff --git a/Makefile b/Makefile index 4a5e001f71..2aba75c5e9 100644 --- a/Makefile +++ b/Makefile @@ -103,7 +103,6 @@ PROTOBUF_VERSION := $(eval PROTOBUF_VERSION := $(shell cat versions/PRO REVIEWDOG_VERSION := $(eval REVIEWDOG_VERSION := $(shell cat versions/REVIEWDOG_VERSION))$(REVIEWDOG_VERSION) RUST_VERSION := $(eval RUST_VERSION := $(shell cat versions/RUST_VERSION))$(RUST_VERSION) TELEPRESENCE_VERSION := $(eval TELEPRESENCE_VERSION := $(shell cat versions/TELEPRESENCE_VERSION))$(TELEPRESENCE_VERSION) -VALDCLI_VERSION := $(eval VALDCLI_VERSION := $(shell cat versions/VALDCLI_VERSION))$(VALDCLI_VERSION) YQ_VERSION := $(eval YQ_VERSION := $(shell cat versions/YQ_VERSION))$(YQ_VERSION) ZLIB_VERSION := $(eval ZLIB_VERSION := $(shell cat versions/ZLIB_VERSION))$(ZLIB_VERSION) @@ -455,7 +454,6 @@ init: \ tools/install: \ helm/install \ kind/install \ - valdcli/install \ telepresence/install \ textlint/install @@ -620,10 +618,6 @@ version/helm: version/yq: @echo $(YQ_VERSION) -.PHONY: version/valdcli -version/valdcli: - @echo $(VALDCLI_VERSION) - .PHONY: version/telepresence version/telepresence: @echo $(TELEPRESENCE_VERSION) @@ -737,14 +731,14 @@ files/textlint: \ ## run cspell for document docs/cspell:\ cspell/install - cspell-cli $(ROOTDIR)/docs/**/*.md --show-suggestions $(CSPELL_EXTRA_OPTIONS) + cspell $(ROOTDIR)/docs/**/*.md --show-suggestions $(CSPELL_EXTRA_OPTIONS) .PHONY: files/cspell ## run cspell for document files/cspell: \ files \ cspell/install - cspell-cli $(ROOTDIR)/.gitfiles --show-suggestions $(CSPELL_EXTRA_OPTIONS) + cspell $(ROOTDIR)/.gitfiles --show-suggestions $(CSPELL_EXTRA_OPTIONS) .PHONY: changelog/update ## update changelog @@ -766,7 +760,6 @@ changelog/next/print: include Makefile.d/actions.mk include Makefile.d/bench.mk include Makefile.d/build.mk -include Makefile.d/client.mk include Makefile.d/dependencies.mk include Makefile.d/docker.mk include Makefile.d/e2e.mk @@ -775,7 +768,7 @@ include Makefile.d/helm.mk include Makefile.d/k3d.mk include Makefile.d/k8s.mk include Makefile.d/kind.mk +include Makefile.d/minikube.mk include Makefile.d/proto.mk include Makefile.d/test.mk include Makefile.d/tools.mk -include Makefile.d/minikube.mk diff --git a/Makefile.d/client.mk b/Makefile.d/client.mk deleted file mode 100644 index 1c5c7aa9bf..0000000000 --- a/Makefile.d/client.mk +++ /dev/null @@ -1,45 +0,0 @@ -# -# Copyright (C) 2019-2024 vdaas.org vald team -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# You may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# - -.PHONY: valdcli/install -## install valdcli -valdcli/install: $(BINDIR)/valdcli - -ifeq ($(UNAME),Darwin) -$(BINDIR)/valdcli: - mkdir -p $(BINDIR) - curl -fsSLO https://github.com/rinx/vald-client-clj/releases/download/$(VALDCLI_VERSION)/valdcli-macos.zip - unzip valdcli-macos.zip - rm -f valdcli-macos.zip - mv valdcli $(BINDIR)/valdcli -else -$(BINDIR)/valdcli: - mkdir -p $(BINDIR) - curl -fsSLO https://github.com/rinx/vald-client-clj/releases/download/$(VALDCLI_VERSION)/valdcli-linux-static.zip - unzip valdcli-linux-static.zip - rm -f valdcli-linux-static.zip - mv valdcli $(BINDIR)/valdcli -endif - -.PHONY: valdcli/xpanes/insert -## insert randomized vectors using valdcli and xpanes -valdcli/xpanes/insert: - xpanes -c "valdcli rand-vecs -n $(NUMBER) -d $(DIMENSION) --gaussian --gaussian-mean $(MEAN) --gaussian-stddev $(STDDEV) --with-ids | valdcli -h $(HOST) -p $(PORT) stream-insert --elapsed-time" $$(seq 1 $(NUMPANES)) - -.PHONY: valdcli/xpanes/search -## search randomized vectors using valdcli and xpanes -valdcli/xpanes/search: - xpanes -c "valdcli rand-vecs -n $(NUMBER) -d $(DIMENSION) --gaussian --gaussian-mean $(MEAN) --gaussian-stddev $(STDDEV) | valdcli -h $(HOST) -p $(PORT) stream-search --elapsed-time" $$(seq 1 $(NUMPANES)) diff --git a/Makefile.d/dependencies.mk b/Makefile.d/dependencies.mk index 928ed8c9d2..596e9ec1b2 100644 --- a/Makefile.d/dependencies.mk +++ b/Makefile.d/dependencies.mk @@ -39,7 +39,6 @@ update/libs: \ update/rust \ update/telepresence \ update/vald \ - update/valdcli \ update/yq \ update/zlib @@ -227,11 +226,6 @@ update/hdf5: update/vald: curl -fsSL https://api.github.com/repos/$(REPO)/releases/latest | grep -Po '"tag_name": "\K.*?(?=")' > $(ROOTDIR)/versions/VALD_VERSION -.PHONY: update/valdcli -## update vald client library made by clojure self version -update/valdcli: - curl -fsSL https://api.github.com/repos/$(REPO)-client-clj/releases/latest | grep -Po '"tag_name": "\K.*?(?=")' > $(ROOTDIR)/versions/VALDCLI_VERSION - .PHONY: update/template ## update PULL_REQUEST_TEMPLATE and ISSUE_TEMPLATE update/template: diff --git a/Makefile.d/tools.mk b/Makefile.d/tools.mk index 3502f2e879..c9968e5d75 100644 --- a/Makefile.d/tools.mk +++ b/Makefile.d/tools.mk @@ -89,7 +89,34 @@ textlint/ci/install: cspell/install: $(NPM_GLOBAL_PREFIX)/bin/cspell $(NPM_GLOBAL_PREFIX)/bin/cspell: - npm install -g cspell@latest + npm install -g cspell@latest \ + @cspell/dict-cpp \ + @cspell/dict-docker \ + @cspell/dict-en_us \ + @cspell/dict-fullstack \ + @cspell/dict-git \ + @cspell/dict-golang \ + @cspell/dict-k8s \ + @cspell/dict-makefile \ + @cspell/dict-markdown \ + @cspell/dict-npm \ + @cspell/dict-public-licenses \ + @cspell/dict-rust \ + @cspell/dict-shell + cspell link add @cspell/dict-cpp + cspell link add @cspell/dict-docker + cspell link add @cspell/dict-en_us + cspell link add @cspell/dict-fullstack + cspell link add @cspell/dict-git + cspell link add @cspell/dict-golang + cspell link add @cspell/dict-k8s + cspell link add @cspell/dict-makefile + cspell link add @cspell/dict-markdown + cspell link add @cspell/dict-npm + cspell link add @cspell/dict-public-licenses + cspell link add @cspell/dict-rust + cspell link add @cspell/dict-shell + .PHONY: buf/install buf/install: $(BINDIR)/buf diff --git a/apis/docs/v1/docs.md b/apis/docs/v1/docs.md index 14dab54f00..a8fd026f18 100644 --- a/apis/docs/v1/docs.md +++ b/apis/docs/v1/docs.md @@ -1731,11 +1731,12 @@ Search service provides ways to search indexed vectors. Update service provides ways to update indexed vectors. -| Method Name | Request Type | Response Type | Description | -| ------------ | ------------------------------------------------------------------ | ----------------------------------------------------------------------------- | ----------------------------------------------------------------------- | -| Update | [.payload.v1.Update.Request](#payload-v1-Update-Request) | [.payload.v1.Object.Location](#payload-v1-Object-Location) | A method to update an indexed vector. | -| StreamUpdate | [.payload.v1.Update.Request](#payload-v1-Update-Request) stream | [.payload.v1.Object.StreamLocation](#payload-v1-Object-StreamLocation) stream | A method to update multiple indexed vectors by bidirectional streaming. | -| MultiUpdate | [.payload.v1.Update.MultiRequest](#payload-v1-Update-MultiRequest) | [.payload.v1.Object.Locations](#payload-v1-Object-Locations) | A method to update multiple indexed vectors in a single request. | +| Method Name | Request Type | Response Type | Description | +| --------------- | ------------------------------------------------------------------ | ----------------------------------------------------------------------------- | ----------------------------------------------------------------------- | +| Update | [.payload.v1.Update.Request](#payload-v1-Update-Request) | [.payload.v1.Object.Location](#payload-v1-Object-Location) | A method to update an indexed vector. | +| StreamUpdate | [.payload.v1.Update.Request](#payload-v1-Update-Request) stream | [.payload.v1.Object.StreamLocation](#payload-v1-Object-StreamLocation) stream | A method to update multiple indexed vectors by bidirectional streaming. | +| MultiUpdate | [.payload.v1.Update.MultiRequest](#payload-v1-Update-MultiRequest) | [.payload.v1.Object.Locations](#payload-v1-Object-Locations) | A method to update multiple indexed vectors in a single request. | +| UpdateTimestamp | [.payload.v1.Object.Timestamp](#payload-v1-Object-Timestamp) | [.payload.v1.Object.Location](#payload-v1-Object-Location) | A method to update timestamp an indexed vector. | diff --git a/apis/grpc/v1/vald/update.pb.go b/apis/grpc/v1/vald/update.pb.go index ad05fbe50c..f98b9d1b26 100644 --- a/apis/grpc/v1/vald/update.pb.go +++ b/apis/grpc/v1/vald/update.pb.go @@ -46,7 +46,7 @@ var file_v1_vald_update_proto_rawDesc = []byte{ 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x18, 0x76, 0x31, 0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, - 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x9f, 0x02, 0x0a, 0x06, 0x55, 0x70, 0x64, 0x61, + 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0x81, 0x03, 0x0a, 0x06, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x55, 0x0a, 0x06, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1a, 0x2e, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x70, 0x61, 0x79, 0x6c, 0x6f, @@ -64,32 +64,41 @@ var file_v1_vald_update_proto_rawDesc = []byte{ 0x2e, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x1b, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x15, 0x3a, 0x01, 0x2a, 0x22, 0x10, 0x2f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, - 0x2f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x42, 0x53, 0x0a, 0x1a, 0x6f, 0x72, 0x67, - 0x2e, 0x76, 0x64, 0x61, 0x61, 0x73, 0x2e, 0x76, 0x61, 0x6c, 0x64, 0x2e, 0x61, 0x70, 0x69, 0x2e, - 0x76, 0x31, 0x2e, 0x76, 0x61, 0x6c, 0x64, 0x42, 0x0a, 0x56, 0x61, 0x6c, 0x64, 0x55, 0x70, 0x64, - 0x61, 0x74, 0x65, 0x50, 0x01, 0x5a, 0x27, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, - 0x6d, 0x2f, 0x76, 0x64, 0x61, 0x61, 0x73, 0x2f, 0x76, 0x61, 0x6c, 0x64, 0x2f, 0x61, 0x70, 0x69, - 0x73, 0x2f, 0x67, 0x72, 0x70, 0x63, 0x2f, 0x76, 0x31, 0x2f, 0x76, 0x61, 0x6c, 0x64, 0x62, 0x06, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x2f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x12, 0x60, 0x0a, 0x0f, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x1c, 0x2e, 0x70, + 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, + 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x1a, 0x1b, 0x2e, 0x70, 0x61, 0x79, + 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x76, 0x31, 0x2e, 0x4f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x2e, 0x4c, + 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x12, 0x82, 0xd3, 0xe4, 0x93, 0x02, 0x0c, 0x3a, + 0x01, 0x2a, 0x22, 0x07, 0x2f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x42, 0x53, 0x0a, 0x1a, 0x6f, + 0x72, 0x67, 0x2e, 0x76, 0x64, 0x61, 0x61, 0x73, 0x2e, 0x76, 0x61, 0x6c, 0x64, 0x2e, 0x61, 0x70, + 0x69, 0x2e, 0x76, 0x31, 0x2e, 0x76, 0x61, 0x6c, 0x64, 0x42, 0x0a, 0x56, 0x61, 0x6c, 0x64, 0x55, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x01, 0x5a, 0x27, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x76, 0x64, 0x61, 0x61, 0x73, 0x2f, 0x76, 0x61, 0x6c, 0x64, 0x2f, 0x61, + 0x70, 0x69, 0x73, 0x2f, 0x67, 0x72, 0x70, 0x63, 0x2f, 0x76, 0x31, 0x2f, 0x76, 0x61, 0x6c, 0x64, + 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var file_v1_vald_update_proto_goTypes = []any{ (*payload.Update_Request)(nil), // 0: payload.v1.Update.Request (*payload.Update_MultiRequest)(nil), // 1: payload.v1.Update.MultiRequest - (*payload.Object_Location)(nil), // 2: payload.v1.Object.Location - (*payload.Object_StreamLocation)(nil), // 3: payload.v1.Object.StreamLocation - (*payload.Object_Locations)(nil), // 4: payload.v1.Object.Locations + (*payload.Object_Timestamp)(nil), // 2: payload.v1.Object.Timestamp + (*payload.Object_Location)(nil), // 3: payload.v1.Object.Location + (*payload.Object_StreamLocation)(nil), // 4: payload.v1.Object.StreamLocation + (*payload.Object_Locations)(nil), // 5: payload.v1.Object.Locations } var file_v1_vald_update_proto_depIdxs = []int32{ 0, // 0: vald.v1.Update.Update:input_type -> payload.v1.Update.Request 0, // 1: vald.v1.Update.StreamUpdate:input_type -> payload.v1.Update.Request 1, // 2: vald.v1.Update.MultiUpdate:input_type -> payload.v1.Update.MultiRequest - 2, // 3: vald.v1.Update.Update:output_type -> payload.v1.Object.Location - 3, // 4: vald.v1.Update.StreamUpdate:output_type -> payload.v1.Object.StreamLocation - 4, // 5: vald.v1.Update.MultiUpdate:output_type -> payload.v1.Object.Locations - 3, // [3:6] is the sub-list for method output_type - 0, // [0:3] is the sub-list for method input_type + 2, // 3: vald.v1.Update.UpdateTimestamp:input_type -> payload.v1.Object.Timestamp + 3, // 4: vald.v1.Update.Update:output_type -> payload.v1.Object.Location + 4, // 5: vald.v1.Update.StreamUpdate:output_type -> payload.v1.Object.StreamLocation + 5, // 6: vald.v1.Update.MultiUpdate:output_type -> payload.v1.Object.Locations + 3, // 7: vald.v1.Update.UpdateTimestamp:output_type -> payload.v1.Object.Location + 4, // [4:8] is the sub-list for method output_type + 0, // [0:4] is the sub-list for method input_type 0, // [0:0] is the sub-list for extension type_name 0, // [0:0] is the sub-list for extension extendee 0, // [0:0] is the sub-list for field type_name diff --git a/apis/grpc/v1/vald/update_vtproto.pb.go b/apis/grpc/v1/vald/update_vtproto.pb.go index 60f92fd0a8..6fc00c758c 100644 --- a/apis/grpc/v1/vald/update_vtproto.pb.go +++ b/apis/grpc/v1/vald/update_vtproto.pb.go @@ -48,6 +48,8 @@ type UpdateClient interface { StreamUpdate(ctx context.Context, opts ...grpc.CallOption) (Update_StreamUpdateClient, error) // A method to update multiple indexed vectors in a single request. MultiUpdate(ctx context.Context, in *payload.Update_MultiRequest, opts ...grpc.CallOption) (*payload.Object_Locations, error) + // A method to update timestamp an indexed vector. + UpdateTimestamp(ctx context.Context, in *payload.Object_Timestamp, opts ...grpc.CallOption) (*payload.Object_Location, error) } type updateClient struct { @@ -113,6 +115,17 @@ func (c *updateClient) MultiUpdate( return out, nil } +func (c *updateClient) UpdateTimestamp( + ctx context.Context, in *payload.Object_Timestamp, opts ...grpc.CallOption, +) (*payload.Object_Location, error) { + out := new(payload.Object_Location) + err := c.cc.Invoke(ctx, "/vald.v1.Update/UpdateTimestamp", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // UpdateServer is the server API for Update service. // All implementations must embed UnimplementedUpdateServer // for forward compatibility @@ -123,6 +136,8 @@ type UpdateServer interface { StreamUpdate(Update_StreamUpdateServer) error // A method to update multiple indexed vectors in a single request. MultiUpdate(context.Context, *payload.Update_MultiRequest) (*payload.Object_Locations, error) + // A method to update timestamp an indexed vector. + UpdateTimestamp(context.Context, *payload.Object_Timestamp) (*payload.Object_Location, error) mustEmbedUnimplementedUpdateServer() } @@ -144,6 +159,12 @@ func (UnimplementedUpdateServer) MultiUpdate( ) (*payload.Object_Locations, error) { return nil, status.Errorf(codes.Unimplemented, "method MultiUpdate not implemented") } + +func (UnimplementedUpdateServer) UpdateTimestamp( + context.Context, *payload.Object_Timestamp, +) (*payload.Object_Location, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateTimestamp not implemented") +} func (UnimplementedUpdateServer) mustEmbedUnimplementedUpdateServer() {} // UnsafeUpdateServer may be embedded to opt out of forward compatibility for this service. @@ -223,6 +244,26 @@ func _Update_MultiUpdate_Handler( return interceptor(ctx, in, info, handler) } +func _Update_UpdateTimestamp_Handler( + srv any, ctx context.Context, dec func(any) error, interceptor grpc.UnaryServerInterceptor, +) (any, error) { + in := new(payload.Object_Timestamp) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(UpdateServer).UpdateTimestamp(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/vald.v1.Update/UpdateTimestamp", + } + handler := func(ctx context.Context, req any) (any, error) { + return srv.(UpdateServer).UpdateTimestamp(ctx, req.(*payload.Object_Timestamp)) + } + return interceptor(ctx, in, info, handler) +} + // Update_ServiceDesc is the grpc.ServiceDesc for Update service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) @@ -238,6 +279,10 @@ var Update_ServiceDesc = grpc.ServiceDesc{ MethodName: "MultiUpdate", Handler: _Update_MultiUpdate_Handler, }, + { + MethodName: "UpdateTimestamp", + Handler: _Update_UpdateTimestamp_Handler, + }, }, Streams: []grpc.StreamDesc{ { diff --git a/apis/grpc/v1/vald/vald.go b/apis/grpc/v1/vald/vald.go index 3ff180c0e8..f65f2a3e40 100644 --- a/apis/grpc/v1/vald/vald.go +++ b/apis/grpc/v1/vald/vald.go @@ -95,6 +95,7 @@ const ( UpdateObjectRPCName = "UpdateObject" StreamUpdateObjectRPCName = "StreamUpdateObject" MultiUpdateObjectRPCName = "MultiUpdateObject" + UpdateTimestampRPCName = "UpdateTimestamp" UpsertRPCName = "Upsert" StreamUpsertRPCName = "StreamUpsert" diff --git a/apis/proto/v1/vald/update.proto b/apis/proto/v1/vald/update.proto index 4cab1cabf0..ccd715efd7 100644 --- a/apis/proto/v1/vald/update.proto +++ b/apis/proto/v1/vald/update.proto @@ -46,4 +46,12 @@ service Update { body: "*" }; } + + // A method to update timestamp an indexed vector. + rpc UpdateTimestamp(payload.v1.Object.Timestamp) returns (payload.v1.Object.Location) { + option (google.api.http) = { + post: "/update" + body: "*" + }; + } } diff --git a/apis/swagger/v1/vald/update.swagger.json b/apis/swagger/v1/vald/update.swagger.json index d295febc19..85c729d702 100644 --- a/apis/swagger/v1/vald/update.swagger.json +++ b/apis/swagger/v1/vald/update.swagger.json @@ -14,8 +14,8 @@ "paths": { "/update": { "post": { - "summary": "A method to update an indexed vector.", - "operationId": "Update_Update", + "summary": "A method to update timestamp an indexed vector.", + "operationId": "Update_UpdateTimestamp", "responses": { "200": { "description": "A successful response.", @@ -33,11 +33,11 @@ "parameters": [ { "name": "body", - "description": "Represent the update request.", + "description": "Represent a vector meta data.", "in": "body", "required": true, "schema": { - "$ref": "#/definitions/v1UpdateRequest" + "$ref": "#/definitions/v1ObjectTimestamp" } } ], @@ -212,6 +212,21 @@ }, "description": "Represent the vector location." }, + "v1ObjectTimestamp": { + "type": "object", + "properties": { + "id": { + "type": "string", + "description": "The vector ID." + }, + "timestamp": { + "type": "string", + "format": "int64", + "description": "timestamp represents when this vector inserted." + } + }, + "description": "Represent a vector meta data." + }, "v1UpdateConfig": { "type": "object", "properties": { diff --git a/charts/vald-benchmark-operator/README.md b/charts/vald-benchmark-operator/README.md index a5117ebca4..bc3dda2a40 100644 --- a/charts/vald-benchmark-operator/README.md +++ b/charts/vald-benchmark-operator/README.md @@ -230,7 +230,7 @@ Run the following command to install the chart, | server_config.servers.grpc.server.probe_wait_time | string | `"3s"` | | | server_config.servers.grpc.server.restart | bool | `true` | | | server_config.servers.grpc.server.socket_path | string | `""` | | -| server_config.servers.grpc.serviecPort | int | `8081` | | +| server_config.servers.grpc.servicePort | int | `8081` | | | server_config.servers.rest.enabled | bool | `false` | | | server_config.tls.ca | string | `"/path/to/ca"` | | | server_config.tls.cert | string | `"/path/to/cert"` | | diff --git a/charts/vald-benchmark-operator/schemas/job-values.yaml b/charts/vald-benchmark-operator/schemas/job-values.yaml index a619e55d4d..1e166a1db0 100644 --- a/charts/vald-benchmark-operator/schemas/job-values.yaml +++ b/charts/vald-benchmark-operator/schemas/job-values.yaml @@ -800,7 +800,7 @@ server_config: reuse_port: true # server_config.healths.readiness.server.socket_option.reuse_addr -- server listen socket option for reuse_addr functionality reuse_addr: true - # server_config.healths.readiness.server.socket_option.tcp_fast_oepn -- server listen socket option for tcp_fast_open functionality + # server_config.healths.readiness.server.socket_option.tcp_fast_open -- server listen socket option for tcp_fast_open functionality tcp_fast_open: true # server_config.healths.readiness.server.socket_option.tcp_no_delay -- server listen socket option for tcp_no_delay functionality tcp_no_delay: true diff --git a/charts/vald-benchmark-operator/templates/deployment.yaml b/charts/vald-benchmark-operator/templates/deployment.yaml index 14df9b4c2c..e8d36b3a41 100644 --- a/charts/vald-benchmark-operator/templates/deployment.yaml +++ b/charts/vald-benchmark-operator/templates/deployment.yaml @@ -47,7 +47,7 @@ spec: {{- if .Values.podAnnotations }} {{- toYaml . | nindent 8 }} {{- end }} - {{- if .Values.server_config.metrics.pprof.enabeld }} + {{- if .Values.server_config.metrics.pprof.enabled }} pyroscope.io/scrape: "true" pyroscope.io/application-name: {{ .Values.name }} pyroscope.io/profile-cpu-enabled: "true" diff --git a/charts/vald-benchmark-operator/values.yaml b/charts/vald-benchmark-operator/values.yaml index 0712043902..c044d2656d 100644 --- a/charts/vald-benchmark-operator/values.yaml +++ b/charts/vald-benchmark-operator/values.yaml @@ -384,7 +384,7 @@ server_config: # @schema {"name": "server_config.servers.grpc.port", "type": "integer"} port: 8081 # @schema {"name": "server_config.servers.grpc.servicePort", "type": "integer"} - serviecPort: 8081 + servicePort: 8081 # @schema {"name": "server_config.servers.grpc.server", "type": "object"} server: # @schema {"name": "server_config.servers.grpc.server.mode", "type": "string"} diff --git a/charts/vald/values.yaml b/charts/vald/values.yaml index 807d3f57b1..02f2bb634a 100644 --- a/charts/vald/values.yaml +++ b/charts/vald/values.yaml @@ -530,7 +530,7 @@ defaults: reuse_port: true # defaults.server_config.healths.readiness.server.socket_option.reuse_addr -- server listen socket option for reuse_addr functionality reuse_addr: true - # defaults.server_config.healths.readiness.server.socket_option.tcp_fast_oepn -- server listen socket option for tcp_fast_open functionality + # defaults.server_config.healths.readiness.server.socket_option.tcp_fast_open -- server listen socket option for tcp_fast_open functionality tcp_fast_open: true # defaults.server_config.healths.readiness.server.socket_option.tcp_no_delay -- server listen socket option for tcp_no_delay functionality tcp_no_delay: true diff --git a/dockers/agent/core/agent/Dockerfile b/dockers/agent/core/agent/Dockerfile index f3195dde42..565417f97e 100644 --- a/dockers/agent/core/agent/Dockerfile +++ b/dockers/agent/core/agent/Dockerfile @@ -36,7 +36,7 @@ ENV LC_ALL=en_US.UTF-8 ENV ORG=vdaas ENV PKG=agent/core/agent ENV REPO=vald -ENV RUST_HOME=/usr/loacl/lib/rust +ENV RUST_HOME=/usr/local/lib/rust ENV TZ=Etc/UTC ENV USER=root ENV CARGO_HOME=${RUST_HOME}/cargo @@ -48,8 +48,9 @@ SHELL ["/bin/bash", "-o", "pipefail", "-c"] RUN --mount=type=bind,target=.,rw \ --mount=type=tmpfs,target=/tmp \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ - --mount=type=cache,target=/var/cache/apt,sharing=locked\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target=/var/cache/apt,sharing=locked \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/agent/core/faiss/Dockerfile b/dockers/agent/core/faiss/Dockerfile index 463e13494b..bd71909ecb 100644 --- a/dockers/agent/core/faiss/Dockerfile +++ b/dockers/agent/core/faiss/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/agent/core/ngt/Dockerfile b/dockers/agent/core/ngt/Dockerfile index cf0bbcdce2..7e18ddb3ea 100644 --- a/dockers/agent/core/ngt/Dockerfile +++ b/dockers/agent/core/ngt/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/agent/sidecar/Dockerfile b/dockers/agent/sidecar/Dockerfile index 2b06e565fd..09d2ff15c6 100644 --- a/dockers/agent/sidecar/Dockerfile +++ b/dockers/agent/sidecar/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/buildkit/syft/scanner/Dockerfile b/dockers/buildkit/syft/scanner/Dockerfile index 4a23207c47..df32fe5705 100644 --- a/dockers/buildkit/syft/scanner/Dockerfile +++ b/dockers/buildkit/syft/scanner/Dockerfile @@ -16,4 +16,4 @@ # # DO_NOT_EDIT this Dockerfile is generated by https://github.com/vdaas/vald/blob/main/hack/docker/gen/main.go -FROM docker/buildkit-syft-scanner:edge AS scanner +FROM docker/buildkit-syft-scanner:edge AS scanner \ No newline at end of file diff --git a/dockers/ci/base/Dockerfile b/dockers/ci/base/Dockerfile index 09fccb1e35..a2cc22d80e 100644 --- a/dockers/ci/base/Dockerfile +++ b/dockers/ci/base/Dockerfile @@ -41,11 +41,11 @@ ENV LC_ALL=en_US.UTF-8 ENV ORG=vdaas ENV PKG=ci/base ENV REPO=vald -ENV RUST_HOME=/usr/loacl/lib/rust +ENV RUST_HOME=/usr/local/lib/rust ENV TZ=Etc/UTC ENV USER=root -ENV RUSTUP_HOME=${RUST_HOME}/rustup ENV CARGO_HOME=${RUST_HOME}/cargo +ENV RUSTUP_HOME=${RUST_HOME}/rustup ENV PATH=${CARGO_HOME}/bin:${GOPATH}/bin:${GOROOT}/bin:${RUSTUP_HOME}/bin:/usr/local/bin:${PATH} WORKDIR ${GOPATH}/src/github.com/${ORG}/${REPO} SHELL ["/bin/bash", "-o", "pipefail", "-c"] @@ -55,8 +55,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ @@ -113,7 +115,6 @@ RUN --mount=type=bind,target=.,rw \ && make kubelinter/install \ && make reviewdog/install \ && make tparse/install \ - && make valdcli/install \ && make yq/install \ && make minikube/install \ && make stern/install \ diff --git a/dockers/dev/Dockerfile b/dockers/dev/Dockerfile index 502f386e97..6dc1b1d7fc 100644 --- a/dockers/dev/Dockerfile +++ b/dockers/dev/Dockerfile @@ -41,11 +41,11 @@ ENV LC_ALL=en_US.UTF-8 ENV ORG=vdaas ENV PKG=dev ENV REPO=vald -ENV RUST_HOME=/usr/loacl/lib/rust +ENV RUST_HOME=/usr/local/lib/rust ENV TZ=Etc/UTC ENV USER=root -ENV CARGO_HOME=${RUST_HOME}/cargo ENV RUSTUP_HOME=${RUST_HOME}/rustup +ENV CARGO_HOME=${RUST_HOME}/cargo ENV PATH=${CARGO_HOME}/bin:${GOPATH}/bin:${GOROOT}/bin:${RUSTUP_HOME}/bin:/usr/local/bin:${PATH} WORKDIR ${GOPATH}/src/github.com/${ORG}/${REPO} SHELL ["/bin/bash", "-o", "pipefail", "-c"] @@ -55,8 +55,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ @@ -133,7 +135,6 @@ RUN --mount=type=bind,target=.,rw \ && make kubelinter/install \ && make reviewdog/install \ && make tparse/install \ - && make valdcli/install \ && make yq/install \ && make minikube/install \ && make stern/install \ diff --git a/dockers/discoverer/k8s/Dockerfile b/dockers/discoverer/k8s/Dockerfile index 19e5953ee2..eda98e6228 100644 --- a/dockers/discoverer/k8s/Dockerfile +++ b/dockers/discoverer/k8s/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/gateway/filter/Dockerfile b/dockers/gateway/filter/Dockerfile index b523b5e5b8..9e11bf47df 100644 --- a/dockers/gateway/filter/Dockerfile +++ b/dockers/gateway/filter/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/gateway/lb/Dockerfile b/dockers/gateway/lb/Dockerfile index 2f8c91768b..f42a143ec3 100644 --- a/dockers/gateway/lb/Dockerfile +++ b/dockers/gateway/lb/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/gateway/mirror/Dockerfile b/dockers/gateway/mirror/Dockerfile index 9b97231c74..87595ffe75 100644 --- a/dockers/gateway/mirror/Dockerfile +++ b/dockers/gateway/mirror/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/index/job/correction/Dockerfile b/dockers/index/job/correction/Dockerfile index 01e3818c56..9f5fec6b97 100644 --- a/dockers/index/job/correction/Dockerfile +++ b/dockers/index/job/correction/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/index/job/creation/Dockerfile b/dockers/index/job/creation/Dockerfile index d656b3ad22..dcfe67b9f5 100644 --- a/dockers/index/job/creation/Dockerfile +++ b/dockers/index/job/creation/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/index/job/readreplica/rotate/Dockerfile b/dockers/index/job/readreplica/rotate/Dockerfile index bdb0ec7664..8311b7cfe8 100644 --- a/dockers/index/job/readreplica/rotate/Dockerfile +++ b/dockers/index/job/readreplica/rotate/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/index/job/save/Dockerfile b/dockers/index/job/save/Dockerfile index fdd674abd4..1c5ecd3d04 100644 --- a/dockers/index/job/save/Dockerfile +++ b/dockers/index/job/save/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/index/operator/Dockerfile b/dockers/index/operator/Dockerfile index 23e9aae514..128383d0d1 100644 --- a/dockers/index/operator/Dockerfile +++ b/dockers/index/operator/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/manager/index/Dockerfile b/dockers/manager/index/Dockerfile index edecb98a6c..e8dcae1bfe 100644 --- a/dockers/manager/index/Dockerfile +++ b/dockers/manager/index/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/operator/helm/Dockerfile b/dockers/operator/helm/Dockerfile index db24094790..1403a9faa9 100644 --- a/dockers/operator/helm/Dockerfile +++ b/dockers/operator/helm/Dockerfile @@ -54,8 +54,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/tools/benchmark/job/Dockerfile b/dockers/tools/benchmark/job/Dockerfile index 65da31d468..3e7c949db9 100644 --- a/dockers/tools/benchmark/job/Dockerfile +++ b/dockers/tools/benchmark/job/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/tools/benchmark/operator/Dockerfile b/dockers/tools/benchmark/operator/Dockerfile index 283773b11e..08c6ff1571 100644 --- a/dockers/tools/benchmark/operator/Dockerfile +++ b/dockers/tools/benchmark/operator/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/dockers/tools/cli/loadtest/Dockerfile b/dockers/tools/cli/loadtest/Dockerfile index ffbea81b05..d8efa32718 100644 --- a/dockers/tools/cli/loadtest/Dockerfile +++ b/dockers/tools/cli/loadtest/Dockerfile @@ -50,8 +50,10 @@ RUN --mount=type=bind,target=.,rw \ --mount=type=cache,target=/var/lib/apt,sharing=locked \ --mount=type=cache,target=/var/cache/apt,sharing=locked \ --mount=type=cache,target="${GOPATH}/pkg",id="go-build-${TARGETARCH}" \ - --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}"\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ + --mount=type=cache,target="${HOME}/.cache/go-build",id="go-build-${TARGETARCH}" \ + --mount=type=tmpfs,target="${GOPATH}/src" \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ diff --git a/docs/contributing/unit-test-guideline.md b/docs/contributing/unit-test-guideline.md index 833e65addf..41341bd704 100644 --- a/docs/contributing/unit-test-guideline.md +++ b/docs/contributing/unit-test-guideline.md @@ -128,7 +128,7 @@ You have to create unit tests for error patterns as the same as success patterns #### Advanced -##### Robust boudary test +##### Robust boundary test The previous section is about the basic test cases. The (robust) boundary test should be applied to cover more test coverage. diff --git a/docs/user-guides/observability-configuration.md b/docs/user-guides/observability-configuration.md index 677781f191..db965a9417 100644 --- a/docs/user-guides/observability-configuration.md +++ b/docs/user-guides/observability-configuration.md @@ -176,7 +176,7 @@ defaults: #### Specify the Telemetry attribute -You can add the component information to the attribute of telemetry data by editing `defaults.observability.otlp.attirbute`. +You can add the component information to the attribute of telemetry data by editing `defaults.observability.otlp.attribute`. E.g., when setting `vald-agent-ngt-0` as `agent.observability.otlp.attribute.pod_name`, `target_pod: vald-agent-ngt-0` will be added to the attribute. These attributes are set auto by the environment values, so Vald recommends using default values unless there is a specific reason. diff --git a/example/client/go.mod b/example/client/go.mod index 977d0df4ce..20d6aafd54 100644 --- a/example/client/go.mod +++ b/example/client/go.mod @@ -11,9 +11,9 @@ replace ( golang.org/x/crypto => golang.org/x/crypto v0.26.0 golang.org/x/net => golang.org/x/net v0.28.0 golang.org/x/text => golang.org/x/text v0.17.0 - google.golang.org/genproto => google.golang.org/genproto v0.0.0-20240814211410-ddb44dafa142 - google.golang.org/genproto/googleapis/api => google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142 - google.golang.org/genproto/googleapis/rpc => google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 + google.golang.org/genproto => google.golang.org/genproto v0.0.0-20240823204242-4ba0660f739c + google.golang.org/genproto/googleapis/api => google.golang.org/genproto/googleapis/api v0.0.0-20240823204242-4ba0660f739c + google.golang.org/genproto/googleapis/rpc => google.golang.org/genproto/googleapis/rpc v0.0.0-20240823204242-4ba0660f739c google.golang.org/grpc => google.golang.org/grpc v1.65.0 google.golang.org/protobuf => google.golang.org/protobuf v1.34.2 gopkg.in/yaml.v2 => gopkg.in/yaml.v2 v2.4.0 @@ -37,6 +37,6 @@ require ( golang.org/x/sys v0.23.0 // indirect golang.org/x/text v0.17.0 // indirect google.golang.org/genproto/googleapis/api v0.0.0-20240528184218-531527333157 // indirect - google.golang.org/genproto/googleapis/rpc v0.0.0-20240730163845-b1a4ccb954bf // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 // indirect google.golang.org/protobuf v1.34.2 // indirect ) diff --git a/example/client/go.sum b/example/client/go.sum index ddee44829b..25c5111d29 100644 --- a/example/client/go.sum +++ b/example/client/go.sum @@ -30,10 +30,10 @@ golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc= golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= gonum.org/v1/hdf5 v0.0.0-20210714002203-8c5d23bc6946 h1:vJpL69PeUullhJyKtTjHjENEmZU3BkO4e+fod7nKzgM= gonum.org/v1/hdf5 v0.0.0-20210714002203-8c5d23bc6946/go.mod h1:BQUWDHIAygjdt1HnUPQ0eWqLN2n5FwJycrpYUVUOx2I= -google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142 h1:wKguEg1hsxI2/L3hUYrpo1RVi48K+uTyzKqprwLXsb8= -google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142/go.mod h1:d6be+8HhtEtucleCbxpPW9PA9XwISACu8nvpPqF0BVo= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 h1:e7S5W7MGGLaSu8j3YjdezkZ+m1/Nm0uRVRMEMGk26Xs= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= +google.golang.org/genproto/googleapis/api v0.0.0-20240823204242-4ba0660f739c h1:e0zB268kOca6FbuJkYUGxfwG4DKFZG/8DLyv9Zv66cE= +google.golang.org/genproto/googleapis/api v0.0.0-20240823204242-4ba0660f739c/go.mod h1:fO8wJzT2zbQbAjbIoos1285VfEIYKDDY+Dt+WpTkh6g= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240823204242-4ba0660f739c h1:Kqjm4WpoWvwhMPcrAczoTyMySQmYa9Wy2iL6Con4zn8= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240823204242-4ba0660f739c/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc= google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ= google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= diff --git a/go.mod b/go.mod index 3e63824046..40713000b3 100644 --- a/go.mod +++ b/go.mod @@ -5,17 +5,17 @@ go 1.23.0 replace ( cloud.google.com/go => cloud.google.com/go v0.115.1 cloud.google.com/go/bigquery => cloud.google.com/go/bigquery v1.62.0 - cloud.google.com/go/compute => cloud.google.com/go/compute v1.27.5 - cloud.google.com/go/datastore => cloud.google.com/go/datastore v1.17.1 + cloud.google.com/go/compute => cloud.google.com/go/compute v1.28.0 + cloud.google.com/go/datastore => cloud.google.com/go/datastore v1.19.0 cloud.google.com/go/firestore => cloud.google.com/go/firestore v1.16.0 - cloud.google.com/go/iam => cloud.google.com/go/iam v1.1.13 - cloud.google.com/go/kms => cloud.google.com/go/kms v1.18.5 - cloud.google.com/go/monitoring => cloud.google.com/go/monitoring v1.20.4 - cloud.google.com/go/pubsub => cloud.google.com/go/pubsub v1.41.0 - cloud.google.com/go/secretmanager => cloud.google.com/go/secretmanager v1.13.6 + cloud.google.com/go/iam => cloud.google.com/go/iam v1.2.0 + cloud.google.com/go/kms => cloud.google.com/go/kms v1.19.0 + cloud.google.com/go/monitoring => cloud.google.com/go/monitoring v1.21.0 + cloud.google.com/go/pubsub => cloud.google.com/go/pubsub v1.42.0 + cloud.google.com/go/secretmanager => cloud.google.com/go/secretmanager v1.14.0 cloud.google.com/go/storage => cloud.google.com/go/storage v1.43.0 - cloud.google.com/go/trace => cloud.google.com/go/trace v1.10.12 - code.cloudfoundry.org/bytefmt => code.cloudfoundry.org/bytefmt v0.1.0 + cloud.google.com/go/trace => cloud.google.com/go/trace v1.11.0 + code.cloudfoundry.org/bytefmt => code.cloudfoundry.org/bytefmt v0.3.0 contrib.go.opencensus.io/exporter/aws => contrib.go.opencensus.io/exporter/aws v0.0.0-20230502192102-15967c811cec contrib.go.opencensus.io/exporter/prometheus => contrib.go.opencensus.io/exporter/prometheus v0.4.2 contrib.go.opencensus.io/integrations/ocsql => contrib.go.opencensus.io/integrations/ocsql v0.1.7 @@ -25,7 +25,7 @@ replace ( github.com/Azure/azure-sdk-for-go/sdk/azcore => github.com/Azure/azure-sdk-for-go/sdk/azcore v1.14.0 github.com/Azure/azure-sdk-for-go/sdk/azidentity => github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.7.0 github.com/Azure/azure-sdk-for-go/sdk/internal => github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 - github.com/Azure/go-amqp => github.com/Azure/go-amqp v1.0.5 + github.com/Azure/go-amqp => github.com/Azure/go-amqp v1.1.0 github.com/Azure/go-autorest => github.com/Azure/go-autorest v14.2.1-0.20240530140449-f7ea664c9cff+incompatible github.com/Azure/go-autorest/autorest => github.com/Azure/go-autorest/autorest v0.11.30-0.20240530140449-f7ea664c9cff github.com/Azure/go-autorest/autorest/adal => github.com/Azure/go-autorest/autorest/adal v0.9.24 @@ -38,8 +38,8 @@ replace ( github.com/DATA-DOG/go-sqlmock => github.com/DATA-DOG/go-sqlmock v1.5.2 github.com/GoogleCloudPlatform/cloudsql-proxy => github.com/GoogleCloudPlatform/cloudsql-proxy v1.37.0 github.com/Masterminds/semver/v3 => github.com/Masterminds/semver/v3 v3.2.1 - github.com/ajstarks/deck => github.com/ajstarks/deck v0.0.0-20240814155529-0478e0c25be8 - github.com/ajstarks/deck/generate => github.com/ajstarks/deck/generate v0.0.0-20240814155529-0478e0c25be8 + github.com/ajstarks/deck => github.com/ajstarks/deck v0.0.0-20240820134305-55491d041044 + github.com/ajstarks/deck/generate => github.com/ajstarks/deck/generate v0.0.0-20240820134305-55491d041044 github.com/ajstarks/svgo => github.com/ajstarks/svgo v0.0.0-20211024235047-1546f124cd8b github.com/akrylysov/pogreb => github.com/akrylysov/pogreb v0.10.2 github.com/antihax/optional => github.com/antihax/optional v1.0.0 @@ -47,10 +47,10 @@ replace ( github.com/aws/aws-sdk-go => github.com/aws/aws-sdk-go v1.55.5 github.com/aws/aws-sdk-go-v2 => github.com/aws/aws-sdk-go-v2 v1.30.4 github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream => github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.4 - github.com/aws/aws-sdk-go-v2/config => github.com/aws/aws-sdk-go-v2/config v1.27.28 - github.com/aws/aws-sdk-go-v2/credentials => github.com/aws/aws-sdk-go-v2/credentials v1.17.28 + github.com/aws/aws-sdk-go-v2/config => github.com/aws/aws-sdk-go-v2/config v1.27.30 + github.com/aws/aws-sdk-go-v2/credentials => github.com/aws/aws-sdk-go-v2/credentials v1.17.29 github.com/aws/aws-sdk-go-v2/feature/ec2/imds => github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.12 - github.com/aws/aws-sdk-go-v2/feature/s3/manager => github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.11 + github.com/aws/aws-sdk-go-v2/feature/s3/manager => github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.14 github.com/aws/aws-sdk-go-v2/internal/configsources => github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.16 github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 => github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.16 github.com/aws/aws-sdk-go-v2/internal/ini => github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1 @@ -58,14 +58,14 @@ replace ( github.com/aws/aws-sdk-go-v2/service/internal/checksum => github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.3.18 github.com/aws/aws-sdk-go-v2/service/internal/presigned-url => github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.18 github.com/aws/aws-sdk-go-v2/service/internal/s3shared => github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.16 - github.com/aws/aws-sdk-go-v2/service/kms => github.com/aws/aws-sdk-go-v2/service/kms v1.35.4 - github.com/aws/aws-sdk-go-v2/service/s3 => github.com/aws/aws-sdk-go-v2/service/s3 v1.59.0 - github.com/aws/aws-sdk-go-v2/service/secretsmanager => github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.32.5 - github.com/aws/aws-sdk-go-v2/service/sns => github.com/aws/aws-sdk-go-v2/service/sns v1.31.4 - github.com/aws/aws-sdk-go-v2/service/sqs => github.com/aws/aws-sdk-go-v2/service/sqs v1.34.4 - github.com/aws/aws-sdk-go-v2/service/ssm => github.com/aws/aws-sdk-go-v2/service/ssm v1.52.5 + github.com/aws/aws-sdk-go-v2/service/kms => github.com/aws/aws-sdk-go-v2/service/kms v1.35.5 + github.com/aws/aws-sdk-go-v2/service/s3 => github.com/aws/aws-sdk-go-v2/service/s3 v1.60.1 + github.com/aws/aws-sdk-go-v2/service/secretsmanager => github.com/aws/aws-sdk-go-v2/service/secretsmanager v1.32.6 + github.com/aws/aws-sdk-go-v2/service/sns => github.com/aws/aws-sdk-go-v2/service/sns v1.31.5 + github.com/aws/aws-sdk-go-v2/service/sqs => github.com/aws/aws-sdk-go-v2/service/sqs v1.34.5 + github.com/aws/aws-sdk-go-v2/service/ssm => github.com/aws/aws-sdk-go-v2/service/ssm v1.52.6 github.com/aws/aws-sdk-go-v2/service/sso => github.com/aws/aws-sdk-go-v2/service/sso v1.22.5 - github.com/aws/aws-sdk-go-v2/service/sts => github.com/aws/aws-sdk-go-v2/service/sts v1.30.4 + github.com/aws/aws-sdk-go-v2/service/sts => github.com/aws/aws-sdk-go-v2/service/sts v1.30.5 github.com/aws/smithy-go => github.com/aws/smithy-go v1.20.4 github.com/benbjohnson/clock => github.com/benbjohnson/clock v1.3.5 github.com/beorn7/perks => github.com/beorn7/perks v1.0.1 @@ -79,7 +79,7 @@ replace ( github.com/chzyer/readline => github.com/chzyer/readline v1.5.1 github.com/chzyer/test => github.com/chzyer/test v1.0.0 github.com/cncf/udpa/go => github.com/cncf/udpa/go v0.0.0-20220112060539-c52dc94e7fbe - github.com/cncf/xds/go => github.com/cncf/xds/go v0.0.0-20240723142845-024c85f92f20 + github.com/cncf/xds/go => github.com/cncf/xds/go v0.0.0-20240822171458-6449f94b4d59 github.com/cockroachdb/apd => github.com/cockroachdb/apd v1.1.0 github.com/coreos/go-systemd/v22 => github.com/coreos/go-systemd/v22 v22.5.0 github.com/cpuguy83/go-md2man/v2 => github.com/cpuguy83/go-md2man/v2 v2.0.4 @@ -146,7 +146,7 @@ replace ( github.com/golang/mock => github.com/golang/mock v1.6.0 github.com/golang/protobuf => github.com/golang/protobuf v1.5.4 github.com/golang/snappy => github.com/golang/snappy v0.0.4 - github.com/google/btree => github.com/google/btree v1.1.2 + github.com/google/btree => github.com/google/btree v1.1.3 github.com/google/gnostic => github.com/google/gnostic v0.7.0 github.com/google/go-cmp => github.com/google/go-cmp v0.6.0 github.com/google/go-replayers/grpcreplay => github.com/google/go-replayers/grpcreplay v1.3.0 @@ -225,7 +225,7 @@ replace ( github.com/niemeyer/pretty => github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e github.com/nxadm/tail => github.com/nxadm/tail v1.4.11 github.com/onsi/ginkgo => github.com/onsi/ginkgo v1.16.5 - github.com/onsi/ginkgo/v2 => github.com/onsi/ginkgo/v2 v2.20.0 + github.com/onsi/ginkgo/v2 => github.com/onsi/ginkgo/v2 v2.20.1 github.com/onsi/gomega => github.com/onsi/gomega v1.34.1 github.com/peterbourgon/diskv => github.com/peterbourgon/diskv v2.0.1+incompatible github.com/phpdave11/gofpdf => github.com/phpdave11/gofpdf v1.4.2 @@ -237,7 +237,7 @@ replace ( github.com/pkg/sftp => github.com/pkg/sftp v1.13.6 github.com/pmezard/go-difflib => github.com/pmezard/go-difflib v1.0.0 github.com/prashantv/gostub => github.com/prashantv/gostub v1.1.0 - github.com/prometheus/client_golang => github.com/prometheus/client_golang v1.20.0 + github.com/prometheus/client_golang => github.com/prometheus/client_golang v1.20.2 github.com/prometheus/client_model => github.com/prometheus/client_model v0.6.1 github.com/prometheus/common => github.com/prometheus/common v0.55.0 github.com/prometheus/procfs => github.com/prometheus/procfs v0.15.1 @@ -248,7 +248,7 @@ replace ( github.com/quasilyte/stdinfo => github.com/quasilyte/stdinfo v0.0.0-20220114132959-f7386bf02567 github.com/rogpeppe/fastuuid => github.com/rogpeppe/fastuuid v1.2.0 github.com/rogpeppe/go-internal => github.com/rogpeppe/go-internal v1.12.0 - github.com/rs/xid => github.com/rs/xid v1.5.0 + github.com/rs/xid => github.com/rs/xid v1.6.0 github.com/rs/zerolog => github.com/rs/zerolog v1.33.0 github.com/russross/blackfriday/v2 => github.com/russross/blackfriday/v2 v2.1.0 github.com/ruudk/golang-pdf417 => github.com/ruudk/golang-pdf417 v0.0.0-20201230142125-a7e3863a1245 @@ -273,19 +273,19 @@ replace ( github.com/xlab/treeprint => github.com/xlab/treeprint v1.2.0 github.com/zeebo/assert => github.com/zeebo/assert v1.3.1 github.com/zeebo/xxh3 => github.com/zeebo/xxh3 v1.0.2 - go.etcd.io/bbolt => go.etcd.io/bbolt v1.3.10 + go.etcd.io/bbolt => go.etcd.io/bbolt v1.3.11 go.opencensus.io => go.opencensus.io v0.24.0 - go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc => go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.53.0 - go.opentelemetry.io/otel => go.opentelemetry.io/otel v1.28.0 + go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc => go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.54.0 + go.opentelemetry.io/otel => go.opentelemetry.io/otel v1.29.0 go.opentelemetry.io/otel/exporters/otlp/internal/retry => go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.17.0 go.opentelemetry.io/otel/exporters/otlp/otlpmetric => go.opentelemetry.io/otel/exporters/otlp/otlpmetric v0.43.0 - go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc => go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.28.0 - go.opentelemetry.io/otel/exporters/otlp/otlptrace => go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 - go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc => go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.28.0 - go.opentelemetry.io/otel/metric => go.opentelemetry.io/otel/metric v1.28.0 - go.opentelemetry.io/otel/sdk => go.opentelemetry.io/otel/sdk v1.28.0 - go.opentelemetry.io/otel/sdk/metric => go.opentelemetry.io/otel/sdk/metric v1.28.0 - go.opentelemetry.io/otel/trace => go.opentelemetry.io/otel/trace v1.28.0 + go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc => go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.29.0 + go.opentelemetry.io/otel/exporters/otlp/otlptrace => go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.29.0 + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc => go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.29.0 + go.opentelemetry.io/otel/metric => go.opentelemetry.io/otel/metric v1.29.0 + go.opentelemetry.io/otel/sdk => go.opentelemetry.io/otel/sdk v1.29.0 + go.opentelemetry.io/otel/sdk/metric => go.opentelemetry.io/otel/sdk/metric v1.29.0 + go.opentelemetry.io/otel/trace => go.opentelemetry.io/otel/trace v1.29.0 go.opentelemetry.io/proto/otlp => go.opentelemetry.io/proto/otlp v1.3.1 go.starlark.net => go.starlark.net v0.0.0-20240725214946-42030a7cedce go.uber.org/atomic => go.uber.org/atomic v1.11.0 @@ -295,8 +295,8 @@ replace ( go.uber.org/zap => go.uber.org/zap v1.27.0 gocloud.dev => gocloud.dev v0.39.0 golang.org/x/crypto => golang.org/x/crypto v0.26.0 - golang.org/x/exp => golang.org/x/exp v0.0.0-20240808152545-0cdaa3abc0fa - golang.org/x/exp/typeparams => golang.org/x/exp/typeparams v0.0.0-20240808152545-0cdaa3abc0fa + golang.org/x/exp => golang.org/x/exp v0.0.0-20240823005443-9b4947da3948 + golang.org/x/exp/typeparams => golang.org/x/exp/typeparams v0.0.0-20240823005443-9b4947da3948 golang.org/x/image => golang.org/x/image v0.19.0 golang.org/x/lint => golang.org/x/lint v0.0.0-20210508222113-6edffad5e616 golang.org/x/mobile => golang.org/x/mobile v0.0.0-20240806205939-81131f6468ab @@ -314,11 +314,11 @@ replace ( gonum.org/v1/gonum => gonum.org/v1/gonum v0.15.1 gonum.org/v1/hdf5 => gonum.org/v1/hdf5 v0.0.0-20210714002203-8c5d23bc6946 gonum.org/v1/plot => gonum.org/v1/plot v0.14.0 - google.golang.org/api => google.golang.org/api v0.192.0 + google.golang.org/api => google.golang.org/api v0.194.0 google.golang.org/appengine => google.golang.org/appengine v1.6.8 - google.golang.org/genproto => google.golang.org/genproto v0.0.0-20240814211410-ddb44dafa142 - google.golang.org/genproto/googleapis/api => google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142 - google.golang.org/genproto/googleapis/rpc => google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 + google.golang.org/genproto => google.golang.org/genproto v0.0.0-20240823204242-4ba0660f739c + google.golang.org/genproto/googleapis/api => google.golang.org/genproto/googleapis/api v0.0.0-20240823204242-4ba0660f739c + google.golang.org/genproto/googleapis/rpc => google.golang.org/genproto/googleapis/rpc v0.0.0-20240823204242-4ba0660f739c google.golang.org/grpc => google.golang.org/grpc v1.65.0 google.golang.org/grpc/cmd/protoc-gen-go-grpc => google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.5.1 google.golang.org/protobuf => google.golang.org/protobuf v1.34.2 @@ -336,7 +336,7 @@ replace ( k8s.io/client-go => k8s.io/client-go v0.30.3 k8s.io/component-base => k8s.io/component-base v0.30.3 k8s.io/klog/v2 => k8s.io/klog/v2 v2.130.1 - k8s.io/kube-openapi => k8s.io/kube-openapi v0.0.0-20240816214639-573285566f34 + k8s.io/kube-openapi => k8s.io/kube-openapi v0.0.0-20240822171749-76de80e0abd9 k8s.io/kubernetes => k8s.io/kubernetes v0.30.3 k8s.io/metrics => k8s.io/metrics v0.30.3 nhooyr.io/websocket => nhooyr.io/websocket v1.8.17 @@ -383,14 +383,14 @@ require ( github.com/zeebo/xxh3 v1.0.2 go.etcd.io/bbolt v1.3.8 go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.53.0 - go.opentelemetry.io/otel v1.28.0 + go.opentelemetry.io/otel v1.29.0 go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v0.0.0-00010101000000-000000000000 - go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 + go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.29.0 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.19.0 - go.opentelemetry.io/otel/metric v1.28.0 - go.opentelemetry.io/otel/sdk v1.28.0 - go.opentelemetry.io/otel/sdk/metric v1.28.0 - go.opentelemetry.io/otel/trace v1.28.0 + go.opentelemetry.io/otel/metric v1.29.0 + go.opentelemetry.io/otel/sdk v1.29.0 + go.opentelemetry.io/otel/sdk/metric v1.29.0 + go.opentelemetry.io/otel/trace v1.29.0 go.uber.org/automaxprocs v0.0.0-00010101000000-000000000000 go.uber.org/goleak v1.3.0 go.uber.org/ratelimit v0.3.1 @@ -405,8 +405,8 @@ require ( golang.org/x/tools v0.24.0 gonum.org/v1/hdf5 v0.0.0-00010101000000-000000000000 gonum.org/v1/plot v0.14.0 - google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142 - google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 + google.golang.org/genproto/googleapis/api v0.0.0-20240822170219-fc7c04adadcd + google.golang.org/genproto/googleapis/rpc v0.0.0-20240822170219-fc7c04adadcd google.golang.org/grpc v1.65.0 google.golang.org/protobuf v1.34.2 gopkg.in/yaml.v2 v2.4.0 @@ -415,14 +415,14 @@ require ( k8s.io/cli-runtime v0.0.0-00010101000000-000000000000 k8s.io/client-go v0.30.3 k8s.io/metrics v0.0.0-00010101000000-000000000000 - k8s.io/utils v0.0.0-20240711033017-18e509b52bc8 + k8s.io/utils v0.0.0-20240821151609-f90d01438635 sigs.k8s.io/controller-runtime v0.0.0-00010101000000-000000000000 sigs.k8s.io/yaml v1.4.0 ) require ( - cloud.google.com/go v0.115.0 // indirect - cloud.google.com/go/auth v0.8.1 // indirect + cloud.google.com/go v0.115.1 // indirect + cloud.google.com/go/auth v0.9.1 // indirect cloud.google.com/go/auth/oauth2adapt v0.2.4 // indirect cloud.google.com/go/compute/metadata v0.5.0 // indirect cloud.google.com/go/iam v1.1.13 // indirect @@ -437,7 +437,7 @@ require ( github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect - github.com/emicklei/go-restful/v3 v3.12.1 // indirect + github.com/emicklei/go-restful/v3 v3.11.0 // indirect github.com/evanphx/json-patch v4.12.0+incompatible // indirect github.com/evanphx/json-patch/v5 v5.9.0 // indirect github.com/felixge/httpsnoop v1.0.4 // indirect @@ -447,7 +447,7 @@ require ( github.com/go-logr/logr v1.4.2 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-openapi/jsonpointer v0.21.0 // indirect - github.com/go-openapi/jsonreference v0.21.0 // indirect + github.com/go-openapi/jsonreference v0.20.2 // indirect github.com/go-openapi/swag v0.23.0 // indirect github.com/go-pdf/fpdf v0.9.0 // indirect github.com/go-toolsmith/astcopy v1.0.2 // indirect @@ -469,7 +469,7 @@ require ( github.com/googleapis/gax-go/v2 v2.13.0 // indirect github.com/gorilla/websocket v1.5.0 // indirect github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7 // indirect - github.com/grpc-ecosystem/grpc-gateway/v2 v2.20.0 // indirect + github.com/grpc-ecosystem/grpc-gateway/v2 v2.22.0 // indirect github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed // indirect github.com/imdario/mergo v0.3.6 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect @@ -506,15 +506,15 @@ require ( go.starlark.net v0.0.0-20230525235612-a134d8f9ddca // indirect go.uber.org/multierr v1.11.0 // indirect golang.org/x/crypto v0.26.0 // indirect - golang.org/x/exp v0.0.0-20240808152545-0cdaa3abc0fa // indirect + golang.org/x/exp v0.0.0-20240823005443-9b4947da3948 // indirect golang.org/x/exp/typeparams v0.0.0-20240213143201-ec583247a57a // indirect golang.org/x/image v0.19.0 // indirect golang.org/x/mod v0.20.0 // indirect golang.org/x/term v0.23.0 // indirect golang.org/x/xerrors v0.0.0-20240716161551-93cc26a95ae9 // indirect gomodules.xyz/jsonpatch/v2 v2.4.0 // indirect - google.golang.org/api v0.191.0 // indirect - google.golang.org/genproto v0.0.0-20240812133136-8ffd90a71988 // indirect + google.golang.org/api v0.193.0 // indirect + google.golang.org/genproto v0.0.0-20240822170219-fc7c04adadcd // indirect gopkg.in/inf.v0 v0.9.1 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect k8s.io/apiextensions-apiserver v0.30.1 // indirect diff --git a/go.sum b/go.sum index 309a52862a..a90fe8271e 100644 --- a/go.sum +++ b/go.sum @@ -4,19 +4,19 @@ cel.dev/expr v0.15.0 h1:O1jzfJCQBfL5BFoYktaxwIhuttaQPsVWerH9/EEKx0w= cel.dev/expr v0.15.0/go.mod h1:TRSuuV7DlVCE/uwv5QbAiW/v8l5O8C4eEPHeu7gf7Sg= cloud.google.com/go v0.115.1 h1:Jo0SM9cQnSkYfp44+v+NQXHpcHqlnRJk2qxh6yvxxxQ= cloud.google.com/go v0.115.1/go.mod h1:DuujITeaufu3gL68/lOFIirVNJwQeyf5UXyi+Wbgknc= -cloud.google.com/go/accessapproval v1.7.11/go.mod h1:KGK3+CLDWm4BvjN0wFtZqdFUGhxlTvTF6PhAwQJGL4M= -cloud.google.com/go/accesscontextmanager v1.8.9/go.mod h1:IXvQesVgOC7aXgK9OpYFn5eWnzz8fazegIiJ5WnCOVw= +cloud.google.com/go/accessapproval v1.7.12/go.mod h1:wvyt8Okohbq1i8/aPbCMBNwGQFZaNli5d+1qa/5zgGo= cloud.google.com/go/accesscontextmanager v1.8.11/go.mod h1:nwPysISS3KR5qXipAU6cW/UbDavDdTBBgPohbkhGSok= +cloud.google.com/go/accesscontextmanager v1.8.12/go.mod h1:EmaVYmffq+2jA2waP0/XHECDkaOKVztxVsdzl65t8hw= cloud.google.com/go/aiplatform v1.68.0/go.mod h1:105MFA3svHjC3Oazl7yjXAmIR89LKhRAeNdnDKJczME= -cloud.google.com/go/analytics v0.23.6/go.mod h1:cFz5GwWHrWQi8OHKP9ep3Z4pvHgGcG9lPnFQ+8kXsNo= -cloud.google.com/go/apigateway v1.6.11/go.mod h1:4KsrYHn/kSWx8SNUgizvaz+lBZ4uZfU7mUDsGhmkWfM= -cloud.google.com/go/apigeeconnect v1.6.11/go.mod h1:iMQLTeKxtKL+sb0D+pFlS/TO6za2IUOh/cwMEtn/4g0= -cloud.google.com/go/apigeeregistry v0.8.9/go.mod h1:4XivwtSdfSO16XZdMEQDBCMCWDp3jkCBRhVgamQfLSA= -cloud.google.com/go/appengine v1.8.11/go.mod h1:xET3coaDUj+OP4TgnZlgQ+rG2R9fG2nblya13czP56Q= -cloud.google.com/go/area120 v0.8.11/go.mod h1:VBxJejRAJqeuzXQBbh5iHBYUkIjZk5UzFZLCXmzap2o= -cloud.google.com/go/artifactregistry v1.14.13/go.mod h1:zQ/T4xoAFPtcxshl+Q4TJBgsy7APYR/BLd2z3xEAqRA= -cloud.google.com/go/asset v1.19.5/go.mod h1:sqyLOYaLLfc4ACcn3YxqHno+J7lRt9NJTdO50zCUcY0= -cloud.google.com/go/assuredworkloads v1.11.11/go.mod h1:vaYs6+MHqJvLKYgZBOsuuOhBgNNIguhRU0Kt7JTGcnI= +cloud.google.com/go/analytics v0.24.0/go.mod h1:NpavJSb6TSO56hGpX1+4JL7js6AkKl27TEqzW9Sn7E4= +cloud.google.com/go/apigateway v1.6.12/go.mod h1:2RX6Op78cxqMtENfJW8kKpwtBCFVJGyvBtSR9l6v7aM= +cloud.google.com/go/apigeeconnect v1.6.12/go.mod h1:/DSr1IlfzrXeKjS6c3+8P04avr+4U5S7J3F69SNGFkY= +cloud.google.com/go/apigeeregistry v0.8.10/go.mod h1:3uJa4XfNqvhIvKksKEE7UahxZY1/2Uj07cCfT/RJZZM= +cloud.google.com/go/appengine v1.8.12/go.mod h1:31Ib+S1sYnRQmCtfGqEf6EfzsiYy98EuDtLlvmpmx6U= +cloud.google.com/go/area120 v0.8.12/go.mod h1:W94qTbrwhzGimOeoClrGdm5DAkMGlg/V6Maldra5QM8= +cloud.google.com/go/artifactregistry v1.14.14/go.mod h1:lPHksFcKpcZRrhGNx87a6SSygv0hfWi6Cd0gnWIUU4U= +cloud.google.com/go/asset v1.19.6/go.mod h1:UsijVGuWC6uml/+ODlL+mv6e3dZ52fbdOfOkiv4f0cE= +cloud.google.com/go/assuredworkloads v1.11.12/go.mod h1:yYnk9icCH5XEkqjJinBNBDv5mSvi1FYhpA9Q+BpTwew= cloud.google.com/go/auth v0.2.1/go.mod h1:khQRBNrvNoHiHhV1iu2x8fSnlNbCaVHilznW5MAI5GY= cloud.google.com/go/auth v0.3.0/go.mod h1:lBv6NKTWp8E3LPzmO1TbiiRKc4drLOfHsgmlH9ogv5w= cloud.google.com/go/auth v0.4.2/go.mod h1:Kqvlz1cf1sNA0D+sYJnkPQOP+JMHkuHeIgVmCRtZOLc= @@ -26,74 +26,75 @@ cloud.google.com/go/auth v0.6.1/go.mod h1:eFHG7zDzbXHKmjJddFG/rBlcGp6t25SwRUiEQS cloud.google.com/go/auth v0.7.0/go.mod h1:D+WqdrpcjmiCgWrXmLLxOVq1GACoE36chW6KXoEvuIw= cloud.google.com/go/auth v0.7.2/go.mod h1:VEc4p5NNxycWQTMQEDQF0bd6aTMb6VgYDXEwiJJQAbs= cloud.google.com/go/auth v0.8.0/go.mod h1:qGVp/Y3kDRSDZ5gFD/XPUfYQ9xW1iI7q8RIRoCyBbJc= -cloud.google.com/go/auth v0.8.1 h1:QZW9FjC5lZzN864p13YxvAtGUlQ+KgRL+8Sg45Z6vxo= -cloud.google.com/go/auth v0.8.1/go.mod h1:qGVp/Y3kDRSDZ5gFD/XPUfYQ9xW1iI7q8RIRoCyBbJc= +cloud.google.com/go/auth v0.9.0/go.mod h1:2HsApZBr9zGZhC9QAXsYVYaWk8kNUt37uny+XVKi7wM= +cloud.google.com/go/auth v0.9.1 h1:+pMtLEV2k0AXKvs/tGZojuj6QaioxfUjOpMsG5Gtx+w= +cloud.google.com/go/auth v0.9.1/go.mod h1:Sw8ocT5mhhXxFklyhT12Eiy0ed6tTrPMCJjSI8KhYLk= cloud.google.com/go/auth/oauth2adapt v0.2.2/go.mod h1:wcYjgpZI9+Yu7LyYBg4pqSiaRkfEK3GQcpb7C/uyF1Q= cloud.google.com/go/auth/oauth2adapt v0.2.3/go.mod h1:tMQXOfZzFuNuUxOypHlQEXgdfX5cuhwU+ffUuXRJE8I= cloud.google.com/go/auth/oauth2adapt v0.2.4 h1:0GWE/FUsXhf6C+jAkWgYm7X9tK8cuEIfy19DBn6B6bY= cloud.google.com/go/auth/oauth2adapt v0.2.4/go.mod h1:jC/jOpwFP6JBxhB3P5Rr0a9HLMC/Pe3eaL4NmdvqPtc= -cloud.google.com/go/automl v1.13.11/go.mod h1:oMJdXRDOVC+Eq3PnGhhxSut5Hm9TSyVx1aLEOgerOw8= -cloud.google.com/go/baremetalsolution v1.2.10/go.mod h1:eO2c2NMRy5ytcNPhG78KPsWGNsX5W/tUsCOWmYihx6I= -cloud.google.com/go/batch v1.9.2/go.mod h1:smqwS4sleDJVAEzBt/TzFfXLktmWjFNugGDWl8coKX4= -cloud.google.com/go/beyondcorp v1.0.10/go.mod h1:G09WxvxJASbxbrzaJUMVvNsB1ZiaKxpbtkjiFtpDtbo= +cloud.google.com/go/automl v1.13.12/go.mod h1:Rw8hmEIlKyvdhbFXjLrLvM2qNKZNwf5oraS5DervadE= +cloud.google.com/go/baremetalsolution v1.2.11/go.mod h1:bqthxNtU+n3gwWxoyXVR9VdSqIfVcgmpYtBlXQkeWq8= +cloud.google.com/go/batch v1.9.4/go.mod h1:qqfXThFPI9dyDK1PfidiEOM/MrS+jUQualcQJytJCLA= +cloud.google.com/go/beyondcorp v1.0.11/go.mod h1:V0EIXuYoyqKkHfnNCYZrNv6M+WYWJGIr5h019LurF3I= cloud.google.com/go/bigquery v1.62.0/go.mod h1:5ee+ZkF1x/ntgCsFQJAQTM3QkAZOecfCmvxhkJsWRSA= cloud.google.com/go/bigtable v1.18.1/go.mod h1:NAVyfJot9jlo+KmgWLUJ5DJGwNDoChzAcrecLpmuAmY= cloud.google.com/go/bigtable v1.20.0/go.mod h1:upJDn8frsjzpRMfybiWkD1PG6WCCL7CRl26MgVeoXY4= -cloud.google.com/go/bigtable v1.27.2-0.20240802230159-f371928b558f/go.mod h1:avmXcmxVbLJAo9moICRYMgDyTTPoV0MA0lHKnyqV4fQ= -cloud.google.com/go/billing v1.18.9/go.mod h1:bKTnh8MBfCMUT1fzZ936CPN9rZG7ZEiHB2J3SjIjByc= -cloud.google.com/go/binaryauthorization v1.8.7/go.mod h1:cRj4teQhOme5SbWQa96vTDATQdMftdT5324BznxANtg= -cloud.google.com/go/certificatemanager v1.8.5/go.mod h1:r2xINtJ/4xSz85VsqvjY53qdlrdCjyniib9Jp98ZKKM= -cloud.google.com/go/channel v1.17.11/go.mod h1:gjWCDBcTGQce/BSMoe2lAqhlq0dIRiZuktvBKXUawp0= -cloud.google.com/go/cloudbuild v1.16.5/go.mod h1:HXLpZ8QeYZgmDIWpbl9Gs22p6o6uScgQ/cV9HF9cIZU= -cloud.google.com/go/clouddms v1.7.10/go.mod h1:PzHELq0QDyA7VaD9z6mzh2mxeBz4kM6oDe8YxMxd4RA= -cloud.google.com/go/cloudtasks v1.12.12/go.mod h1:8UmM+duMrQpzzRREo0i3x3TrFjsgI/3FQw3664/JblA= -cloud.google.com/go/compute v1.27.5/go.mod h1:DfwDGujFTdSeiE8b8ZqadF/uxHFBz+ekGsk8Zfi9dTA= +cloud.google.com/go/bigtable v1.29.0/go.mod h1:5p909nNdWaNUcWs6KGZO8mI5HUovstlmrIi7+eA5PTQ= +cloud.google.com/go/billing v1.18.10/go.mod h1:Lt+Qrjqsde38l/h1+9fzu44Pv9t+Suyf/p973mrg+xU= +cloud.google.com/go/binaryauthorization v1.8.8/go.mod h1:D7B3gkNPdZ1Zj2IEyfypDTgbwFgTWE2SE6Csz0f46jg= +cloud.google.com/go/certificatemanager v1.8.6/go.mod h1:ZsK7vU+XFDfSRwOqB4GjAGzawIIA3dWPXaFC9I5Jsts= +cloud.google.com/go/channel v1.17.12/go.mod h1:DoVQacEH1YuNqIZVN8v67cXGxaUyOgjrst+/+pkVqWU= +cloud.google.com/go/cloudbuild v1.16.6/go.mod h1:Y7+6WFO8pT53rG0Lve6OZoO4+RkVTHGnHG7EB3uNiQw= +cloud.google.com/go/clouddms v1.7.11/go.mod h1:rPNK0gJEkF2//rdxhCKhx+IFBlzkObOZhlhvDY1JKCE= +cloud.google.com/go/cloudtasks v1.12.13/go.mod h1:53OmmKqQTocrbeCL13cuaryBQOflyO8s4NxuRHJlXgc= +cloud.google.com/go/compute v1.28.0/go.mod h1:DEqZBtYrDnD5PvjsKwb3onnhX+qjdCVM7eshj1XdjV4= cloud.google.com/go/compute/metadata v0.2.1/go.mod h1:jgHgmJd2RKBGzXqF5LR2EZMGxBkeanZ9wwa75XHJgOM= cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA= cloud.google.com/go/compute/metadata v0.3.0/go.mod h1:zFmK7XCadkQkj6TtorcaGlCW1hT1fIilQDwofLpJ20k= cloud.google.com/go/compute/metadata v0.4.0/go.mod h1:SIQh1Kkb4ZJ8zJ874fqVkslA29PRXuleyj6vOzlbK7M= cloud.google.com/go/compute/metadata v0.5.0 h1:Zr0eK8JbFv6+Wi4ilXAR8FJ3wyNdpxHKJNPos6LTZOY= cloud.google.com/go/compute/metadata v0.5.0/go.mod h1:aHnloV2TPI38yx4s9+wAZhHykWvVCfu7hQbF+9CWoiY= -cloud.google.com/go/contactcenterinsights v1.13.6/go.mod h1:mL+DbN3pMQGaAbDC4wZhryLciwSwHf5Tfk4Itr72Zyk= -cloud.google.com/go/container v1.38.0/go.mod h1:U0uPBvkVWOJGY/0qTVuPS7NeafFEUsHSPqT5pB8+fCY= -cloud.google.com/go/containeranalysis v0.12.1/go.mod h1:+/lcJIQSFt45TC0N9Nq7/dPbl0isk6hnC4EvBBqyXsM= +cloud.google.com/go/contactcenterinsights v1.13.7/go.mod h1:N5D7yxGknC0pDUC1OKOLShGQwpidKizKu3smt08153U= +cloud.google.com/go/container v1.38.1/go.mod h1:2r4Qiz6IG2LhRFfWhPNmrYD7yzdE2B2kghigVWoSw/g= +cloud.google.com/go/containeranalysis v0.12.2/go.mod h1:XF/U1ZJ9kXfl8HWRzuWMtEtzBb8SvJ0zvySrxrQA3N0= cloud.google.com/go/datacatalog v1.20.3/go.mod h1:AKC6vAy5urnMg5eJK3oUjy8oa5zMbiY33h125l8lmlo= -cloud.google.com/go/datacatalog v1.21.0/go.mod h1:DB0QWF9nelpsbB0eR/tA0xbHZZMvpoFD1XFy3Qv/McI= -cloud.google.com/go/dataflow v0.9.11/go.mod h1:CCLufd7I4pPfyp54qMgil/volrL2ZKYjXeYLfQmBGJs= -cloud.google.com/go/dataform v0.9.8/go.mod h1:cGJdyVdunN7tkeXHPNosuMzmryx55mp6cInYBgxN3oA= -cloud.google.com/go/datafusion v1.7.11/go.mod h1:aU9zoBHgYmoPp4dzccgm/Gi4xWDMXodSZlNZ4WNeptw= -cloud.google.com/go/datalabeling v0.8.11/go.mod h1:6IGUV3z7hlkAU5ndKVshv/8z+7pxE+k0qXsEjyzO1Xg= -cloud.google.com/go/dataplex v1.18.2/go.mod h1:NuBpJJMGGQn2xctX+foHEDKRbizwuiHJamKvvSteY3Q= -cloud.google.com/go/dataproc/v2 v2.5.3/go.mod h1:RgA5QR7v++3xfP7DlgY3DUmoDSTaaemPe0ayKrQfyeg= -cloud.google.com/go/dataqna v0.8.11/go.mod h1:74Icl1oFKKZXPd+W7YDtqJLa+VwLV6wZ+UF+sHo2QZQ= -cloud.google.com/go/datastore v1.17.1/go.mod h1:mtzZ2HcVtz90OVrEXXGDc2pO4NM1kiBQy8YV4qGe0ZM= -cloud.google.com/go/datastream v1.10.10/go.mod h1:NqchuNjhPlISvWbk426/AU/S+Kgv7srlID9P5XOAbtg= -cloud.google.com/go/deploy v1.21.0/go.mod h1:PaOfS47VrvmYnxG5vhHg0KU60cKeWcqyLbMBjxS8DW8= -cloud.google.com/go/dialogflow v1.55.0/go.mod h1:0u0hSlJiFpMkMpMNoFrQETwDjaRm8Q8hYKv+jz5JeRA= -cloud.google.com/go/dlp v1.16.0/go.mod h1:LtPZxZAenBXKzvWIOB2hdHIXuEcK0wW0En8//u+/nNA= -cloud.google.com/go/documentai v1.31.0/go.mod h1:5ajlDvaPyl9tc+K/jZE8WtYIqSXqAD33Z1YAYIjfad4= -cloud.google.com/go/domains v0.9.11/go.mod h1:efo5552kUyxsXEz30+RaoIS2lR7tp3M/rhiYtKXkhkk= -cloud.google.com/go/edgecontainer v1.2.5/go.mod h1:OAb6tElD3F3oBujFAup14PKOs9B/lYobTb6LARmoACY= +cloud.google.com/go/datacatalog v1.21.1/go.mod h1:23qsWWm592aQHwZ4or7VDjNhx7DeNklHAPE3GM47d1U= +cloud.google.com/go/dataflow v0.9.12/go.mod h1:+2+80N2FOdDFWYhZdC2uTlX7GHP5kOH4vPNtfadggqQ= +cloud.google.com/go/dataform v0.9.9/go.mod h1:QkiXNcrbFGjYtPtTkn700sfBiGIOG4mmpt26Ds8Ixeg= +cloud.google.com/go/datafusion v1.7.12/go.mod h1:ZUaEMjNVppM5ZasVt87QE0jN57O0LKY3uFe67EQ0GGI= +cloud.google.com/go/datalabeling v0.8.12/go.mod h1:IBbWnl80akCFj7jZ89/dRB/juuXig+QrQoLg24+vidg= +cloud.google.com/go/dataplex v1.18.3/go.mod h1:wcfVhUr529uu9aZSy9WIUUdOCrkB8M5Gikfh3YUuGtE= +cloud.google.com/go/dataproc/v2 v2.5.4/go.mod h1:rpxihxKtWjPl8MDwjGiYgMva8nEWQSyzvl3e0p4ATt4= +cloud.google.com/go/dataqna v0.8.12/go.mod h1:86JdVMqh3521atZY1P7waaa50vzIbErTLY7gsio+umg= +cloud.google.com/go/datastore v1.19.0/go.mod h1:KGzkszuj87VT8tJe67GuB+qLolfsOt6bZq/KFuWaahc= +cloud.google.com/go/datastream v1.10.11/go.mod h1:0d9em/ERaof15lY5JU3pWKF7ZJOHiPKcNJsTCBz6TX8= +cloud.google.com/go/deploy v1.21.2/go.mod h1:BDBWUXXCBGrvYxVmSYXIRdNffioym0ChQWDQS0c/wA8= +cloud.google.com/go/dialogflow v1.56.0/go.mod h1:P1hIske3kr9pSl11nEP4tFfAu2E4US+7PpboeBhM4ag= +cloud.google.com/go/dlp v1.17.0/go.mod h1:9LuCkaCRZxWZ6HyqkmV3/PW0gKIVKoUVNjf0yMKVqMs= +cloud.google.com/go/documentai v1.32.0/go.mod h1:X8skObtXBvR31QF+jERAu4mOCpRiJBaqbMvB3FLnMsA= +cloud.google.com/go/domains v0.9.12/go.mod h1:2YamnZleyO3y5zYV+oASWAUoiHBJ0ZmkEcO6MXs5x3c= +cloud.google.com/go/edgecontainer v1.2.6/go.mod h1:4jyHt4ytGLL8P0S3m6umOL8bJhTw4tVnDUcPQCGlNMM= cloud.google.com/go/errorreporting v0.3.1/go.mod h1:6xVQXU1UuntfAf+bVkFk6nld41+CPyF2NSPCyXE3Ztk= -cloud.google.com/go/essentialcontacts v1.6.12/go.mod h1:UGhWTIYewH8Ma4wDRJp8cMAHUCeAOCKsuwd6GLmmQLc= -cloud.google.com/go/eventarc v1.13.10/go.mod h1:KlCcOMApmUaqOEZUpZRVH+p0nnnsY1HaJB26U4X5KXE= -cloud.google.com/go/filestore v1.8.7/go.mod h1:dKfyH0YdPAKdYHqAR/bxZeil85Y5QmrEVQwIYuRjcXI= +cloud.google.com/go/essentialcontacts v1.6.13/go.mod h1:52AB7Qmi6TBzA/lsSZER7oi4jR/pY0TXC0lNaaAyfA4= +cloud.google.com/go/eventarc v1.13.11/go.mod h1:1PJ+icw2mJYgqUsICg7Cr8gzMw38f3THiSzVSNPFrNQ= +cloud.google.com/go/filestore v1.8.8/go.mod h1:gNT7bpDZSOFWCnRirQw1IehZtA7blbzkO3Q8VQfkeZ0= cloud.google.com/go/firestore v1.16.0/go.mod h1:+22v/7p+WNBSQwdSwP57vz47aZiY+HrDkrOsJNhk7rg= -cloud.google.com/go/functions v1.16.6/go.mod h1:wOzZakhMueNQaBUJdf0yjsJIe0GBRu+ZTvdSTzqHLs0= -cloud.google.com/go/gkebackup v1.5.4/go.mod h1:V+llvHlRD0bCyrkYaAMJX+CHralceQcaOWjNQs8/Ymw= -cloud.google.com/go/gkeconnect v0.8.11/go.mod h1:ejHv5ehbceIglu1GsMwlH0nZpTftjxEY6DX7tvaM8gA= -cloud.google.com/go/gkehub v0.14.11/go.mod h1:CsmDJ4qbBnSPkoBltEubK6qGOjG0xNfeeT5jI5gCnRQ= -cloud.google.com/go/gkemulticloud v1.2.4/go.mod h1:PjTtoKLQpIRztrL+eKQw8030/S4c7rx/WvHydDJlpGE= -cloud.google.com/go/grafeas v0.3.6/go.mod h1:to6ECAPgRO2xeqD8ISXHc70nObJuaKZThreQOjeOH3o= -cloud.google.com/go/gsuiteaddons v1.6.11/go.mod h1:U7mk5PLBzDpHhgHv5aJkuvLp9RQzZFpa8hgWAB+xVIk= -cloud.google.com/go/iam v1.1.13 h1:7zWBXG9ERbMLrzQBRhFliAV+kjcRToDTgQT3CTwYyv4= -cloud.google.com/go/iam v1.1.13/go.mod h1:K8mY0uSXwEXS30KrnVb+j54LB/ntfZu1dr+4zFMNbus= -cloud.google.com/go/iap v1.9.10/go.mod h1:pO0FEirrhMOT1H0WVwpD5dD9r3oBhvsunyBQtNXzzc0= -cloud.google.com/go/ids v1.4.11/go.mod h1:+ZKqWELpJm8WcRRsSvKZWUdkriu4A3XsLLzToTv3418= -cloud.google.com/go/iot v1.7.11/go.mod h1:0vZJOqFy9kVLbUXwTP95e0dWHakfR4u5IWqsKMGIfHk= -cloud.google.com/go/kms v1.18.5/go.mod h1:yXunGUGzabH8rjUPImp2ndHiGolHeWJJ0LODLedicIY= -cloud.google.com/go/language v1.13.0/go.mod h1:B9FbD17g1EkilctNGUDAdSrBHiFOlKNErLljO7jplDU= -cloud.google.com/go/lifesciences v0.9.11/go.mod h1:NMxu++FYdv55TxOBEvLIhiAvah8acQwXsz79i9l9/RY= +cloud.google.com/go/functions v1.18.0/go.mod h1:r8uxxI35hdP2slfTjGJvx04NRy8sP/EXUMZ0NYfBd+w= +cloud.google.com/go/gkebackup v1.5.5/go.mod h1:C/XZ2LoG+V97xGc18oCPniO754E0iHt0OXqKatawBMM= +cloud.google.com/go/gkeconnect v0.8.12/go.mod h1:+SpnnnUx4Xs/mWBJbqC7Mlu9Vv7riQlHSDS1T1ek2+U= +cloud.google.com/go/gkehub v0.14.12/go.mod h1:CNYNBCqjIkE9L70gzbRxZOsc++Wcp2oCLkfuytOFqRM= +cloud.google.com/go/gkemulticloud v1.2.5/go.mod h1:zVRNlO7/jFXmvrkBd+UfhI2T7ZBb+N3b3lt/3K60uS0= +cloud.google.com/go/grafeas v0.3.9/go.mod h1:j8hBcywIqtJ3/3QP9yYB/LqjLWBM9dXumBa+xplvyG0= +cloud.google.com/go/gsuiteaddons v1.6.12/go.mod h1:hqTWzMXCgS/BPuyiWHzDBZC4K3+a9lcJWBUR+i+6D7A= +cloud.google.com/go/iam v1.2.0 h1:kZKMKVNk/IsSSc/udOb83K0hL/Yh/Gcqpz+oAkoIFN8= +cloud.google.com/go/iam v1.2.0/go.mod h1:zITGuWgsLZxd8OwAlX+eMFgZDXzBm7icj1PVTYG766Q= +cloud.google.com/go/iap v1.9.11/go.mod h1:UcvTLqySIc8C3Dw3JPZ7QihzzxVQJ7/KUOL9MjxiPZk= +cloud.google.com/go/ids v1.4.12/go.mod h1:SH2yjlk9fKWrRgob/E0Gd1wM+VFztfTdR+LaJRDMiPw= +cloud.google.com/go/iot v1.7.12/go.mod h1:8ntlg5OWnVodAsbs0KDLY58tKEroy+CYciDX/ONxpl4= +cloud.google.com/go/kms v1.19.0/go.mod h1:e4imokuPJUc17Trz2s6lEXFDt8bgDmvpVynH39bdrHM= +cloud.google.com/go/language v1.13.1/go.mod h1:PY/DAdVW0p2MWl2Lut31AJddEmQBBXMnPUM8nkl/WfA= +cloud.google.com/go/lifesciences v0.9.12/go.mod h1:si0In2nxVPtZnSoDNlEgSV4BJWxxlkdgKh+LXPYMf4w= cloud.google.com/go/logging v1.11.0/go.mod h1:5LDiJC/RxTt+fHc1LAt20R9TKiUTReDg6RuuFOZ67+A= cloud.google.com/go/longrunning v0.1.1/go.mod h1:UUFxuDWkv22EuY93jjmDMFT5GPQKeFVJBIF6QlTqdsE= cloud.google.com/go/longrunning v0.4.1/go.mod h1:4iWDqhBZ70CvZ6BfETbvam3T8FMvLK+eFj0E6AaRQTo= @@ -102,68 +103,67 @@ cloud.google.com/go/longrunning v0.5.2/go.mod h1:nqo6DQbNV2pXhGDbDMoN2bWz68MjZUz cloud.google.com/go/longrunning v0.5.6/go.mod h1:vUaDrWYOMKRuhiv6JBnn49YxCPz2Ayn9GqyjaBT8/mA= cloud.google.com/go/longrunning v0.5.7/go.mod h1:8GClkudohy1Fxm3owmBGid8W0pSgodEMwEAztp38Xng= cloud.google.com/go/longrunning v0.5.9/go.mod h1:HD+0l9/OOW0za6UWdKJtXoFAX/BGg/3Wj8p10NeWF7c= -cloud.google.com/go/longrunning v0.5.10/go.mod h1:tljz5guTr5oc/qhlUjBlk7UAIFMOGuPNxkNDZXlLics= cloud.google.com/go/longrunning v0.5.11/go.mod h1:rDn7//lmlfWV1Dx6IB4RatCPenTwwmqXuiP0/RgoEO4= cloud.google.com/go/longrunning v0.5.12 h1:5LqSIdERr71CqfUsFlJdBpOkBH8FBCFD7P1nTWy3TYE= cloud.google.com/go/longrunning v0.5.12/go.mod h1:S5hMV8CDJ6r50t2ubVJSKQVv5u0rmik5//KgLO3k4lU= -cloud.google.com/go/managedidentities v1.6.11/go.mod h1:df+8oZ1D4Eri+NrcpuiR5Hd6MGgiMqn0ZCzNmBYPS0A= -cloud.google.com/go/maps v1.11.6/go.mod h1:MOS/NN0L6b7Kumr8bLux9XTpd8+D54DYxBMUjq+XfXs= -cloud.google.com/go/mediatranslation v0.8.11/go.mod h1:3sNEm0fx61eHk7rfzBzrljVV9XKr931xI3OFacQBVFg= -cloud.google.com/go/memcache v1.10.11/go.mod h1:ubJ7Gfz/xQawQY5WO5pht4Q0dhzXBFeEszAeEJnwBHU= -cloud.google.com/go/metastore v1.13.10/go.mod h1:RPhMnBxUmTLT1fN7fNbPqtH5EoGHueDxubmJ1R1yT84= -cloud.google.com/go/monitoring v1.20.4/go.mod h1:v7F/UcLRw15EX7xq565N7Ae5tnYEE28+Cl717aTXG4c= -cloud.google.com/go/networkconnectivity v1.14.10/go.mod h1:f7ZbGl4CV08DDb7lw+NmMXQTKKjMhgCEEwFbEukWuOY= -cloud.google.com/go/networkmanagement v1.13.6/go.mod h1:WXBijOnX90IFb6sberjnGrVtZbgDNcPDUYOlGXmG8+4= -cloud.google.com/go/networksecurity v0.9.11/go.mod h1:4xbpOqCwplmFgymAjPFM6ZIplVC6+eQ4m7sIiEq9oJA= -cloud.google.com/go/notebooks v1.11.9/go.mod h1:JmnRX0eLgHRJiyxw8HOgumW9iRajImZxr7r75U16uXw= -cloud.google.com/go/optimization v1.6.9/go.mod h1:mcvkDy0p4s5k7iSaiKrwwpN0IkteHhGmuW5rP9nXA5M= -cloud.google.com/go/orchestration v1.9.6/go.mod h1:gQvdIsHESZJigimnbUA8XLbYeFlSg/z+A7ppds5JULg= -cloud.google.com/go/orgpolicy v1.12.5/go.mod h1:f778/jOHKp6cP6NbbQgjy4SDfQf6BoVGiSWdxky3ONQ= +cloud.google.com/go/managedidentities v1.6.12/go.mod h1:7KrCfXlxPw85nhlEYF3o5oLC8RtQakMAIGKNiNN3OAg= +cloud.google.com/go/maps v1.11.7/go.mod h1:CEGHM/Q0epp0oWFO7kiEk8oDGUUhjd1sj4Rcd/4iwGU= +cloud.google.com/go/mediatranslation v0.8.12/go.mod h1:owrIOMto4hzsoqkZe95ePEiMJv4JF7/tgEgWuHC+t40= +cloud.google.com/go/memcache v1.10.12/go.mod h1:OfG2zgIXVTNJy2UKDF4o4irKxBqTx9RMZhGKJ/hLJUI= +cloud.google.com/go/metastore v1.13.11/go.mod h1:aeP+V0Xs3SLqu4mrQWRyuSg5+fdyPq+kdu1xclnR8y8= +cloud.google.com/go/monitoring v1.21.0/go.mod h1:tuJ+KNDdJbetSsbSGTqnaBvbauS5kr3Q/koy3Up6r+4= +cloud.google.com/go/networkconnectivity v1.14.11/go.mod h1:XRA6nT7ygTN09gAtCRsFhbqn3u7/9LIUn6S+5G4fs50= +cloud.google.com/go/networkmanagement v1.13.7/go.mod h1:foi1eLe3Ayydrr63O3ViMwG1AGS3/BxRSmXpAqMFhkY= +cloud.google.com/go/networksecurity v0.9.12/go.mod h1:Id0HGMKFJemLolvsoECda71vU2T9JByGPYct6LgMxrw= +cloud.google.com/go/notebooks v1.11.10/go.mod h1:2d3Lwdm5VTxZzxY94V8TffNBk0FBnORieiVBeN+n9QQ= +cloud.google.com/go/optimization v1.6.10/go.mod h1:qWX4Kv90NeBgPfoRwyMbISe8M7Ql1LAOFPNFuOqIvUI= +cloud.google.com/go/orchestration v1.9.7/go.mod h1:Mgtuci4LszRSzKkQucdWvdhTyG+QB4+3ZpsZ4sqalrQ= cloud.google.com/go/orgpolicy v1.12.7/go.mod h1:Os3GlUFRPf1UxOHTup5b70BARnhHeQNNVNZzJXPbWYI= -cloud.google.com/go/osconfig v1.13.0/go.mod h1:tlACnQi1rtSLnHRYzfw9SH9zXs0M7S1jqiW2EOCn2Y0= +cloud.google.com/go/orgpolicy v1.12.8/go.mod h1:WHkLGqHILPnMgJ4UTdag6YgztVIgWS+T5T6tywH3cSM= cloud.google.com/go/osconfig v1.13.2/go.mod h1:eupylkWQJCwSIEMkpVR4LqpgKkQi0mD4m1DzNCgpQso= -cloud.google.com/go/oslogin v1.13.7/go.mod h1:xq027cL0fojpcEcpEQdWayiDn8tIx3WEFYMM6+q7U+E= -cloud.google.com/go/phishingprotection v0.8.11/go.mod h1:Mge0cylqVFs+D0EyxlsTOJ1Guf3qDgrztHzxZqkhRQM= -cloud.google.com/go/policytroubleshooter v1.10.9/go.mod h1:X8HEPVBWz8E+qwI/QXnhBLahEHdcuPO3M9YvSj0LDek= -cloud.google.com/go/privatecatalog v0.9.11/go.mod h1:awEF2a8M6UgoqVJcF/MthkF8SSo6OoWQ7TtPNxUlljY= -cloud.google.com/go/pubsub v1.41.0/go.mod h1:g+YzC6w/3N91tzG66e2BZtp7WrpBBMXVa3Y9zVoOGpk= +cloud.google.com/go/osconfig v1.13.3/go.mod h1:gIFyyriC1ANob8SnpwrQ6jjNroRwItoBOYfqiG3LkUU= +cloud.google.com/go/oslogin v1.13.8/go.mod h1:rc52yAdMXB5mERVeOXRcDnaswQNFTPRJ93VVHmGwJSk= +cloud.google.com/go/phishingprotection v0.8.12/go.mod h1:tkR+cZBpRdu4i04BP1CqaZr2yL7U1o8t+v/SZ2kOSDU= +cloud.google.com/go/policytroubleshooter v1.10.10/go.mod h1:9S7SKOsLydGB2u91WKNjHpLScxxkKATIu3Co0fw8LPQ= +cloud.google.com/go/privatecatalog v0.9.12/go.mod h1:Sl292f/1xY0igI+CFNGfiXJWiN9BvaLpc8mjnCHNRnA= +cloud.google.com/go/pubsub v1.42.0/go.mod h1:KADJ6s4MbTwhXmse/50SebEhE4SmUwHi48z3/dHar1Y= cloud.google.com/go/pubsublite v1.8.2/go.mod h1:4r8GSa9NznExjuLPEJlF1VjOPOpgf3IT6k8x/YgaOPI= -cloud.google.com/go/recaptchaenterprise/v2 v2.14.2/go.mod h1:MwPgdgvBkE46aWuuXeBTCB8hQJ88p+CpXInROZYCTkc= -cloud.google.com/go/recommendationengine v0.8.11/go.mod h1:cEkU4tCXAF88a4boMFZym7U7uyxvVwcQtKzS85IbQio= -cloud.google.com/go/recommender v1.12.7/go.mod h1:lG8DVtczLltWuaCv4IVpNphONZTzaCC9KdxLYeZM5G4= -cloud.google.com/go/redis v1.16.4/go.mod h1:unCVfLP5eFrVhGLDnb7IaSaWxuZ+7cBgwwBwbdG9m9w= -cloud.google.com/go/resourcemanager v1.9.11/go.mod h1:SbNAbjVLoi2rt9G74bEYb3aw1iwvyWPOJMnij4SsmHA= -cloud.google.com/go/resourcesettings v1.7.4/go.mod h1:seBdLuyeq+ol2u9G2+74GkSjQaxaBWF+vVb6mVzQFG0= -cloud.google.com/go/retail v1.17.4/go.mod h1:oPkL1FzW7D+v/hX5alYIx52ro2FY/WPAviwR1kZZTMs= -cloud.google.com/go/run v1.4.0/go.mod h1:4G9iHLjdOC+CQ0CzA0+6nLeR6NezVPmlj+GULmb0zE4= -cloud.google.com/go/scheduler v1.10.12/go.mod h1:6DRtOddMWJ001HJ6MS148rtLSh/S2oqd2hQC3n5n9fQ= -cloud.google.com/go/secretmanager v1.13.6/go.mod h1:x2ySyOrqv3WGFRFn2Xk10iHmNmvmcEVSSqc30eb1bhw= -cloud.google.com/go/security v1.17.4/go.mod h1:KMuDJH+sEB3KTODd/tLJ7kZK+u2PQt+Cfu0oAxzIhgo= -cloud.google.com/go/securitycenter v1.33.1/go.mod h1:jeFisdYUWHr+ig72T4g0dnNCFhRwgwGoQV6GFuEwafw= -cloud.google.com/go/servicedirectory v1.11.11/go.mod h1:pnynaftaj9LmRLIc6t3r7r7rdCZZKKxui/HaF/RqYfs= -cloud.google.com/go/shell v1.7.11/go.mod h1:SywZHWac7onifaT9m9MmegYp3GgCLm+tgk+w2lXK8vg= -cloud.google.com/go/spanner v1.65.0/go.mod h1:dQGB+w5a67gtyE3qSKPPxzniedrnAmV6tewQeBY7Hxs= -cloud.google.com/go/speech v1.24.0/go.mod h1:HcVyIh5jRXM5zDMcbFCW+DF2uK/MSGN6Rastt6bj1ic= +cloud.google.com/go/recaptchaenterprise/v2 v2.14.3/go.mod h1:MiSHAXwja4btHPJFNJrDke//V+x83/ckXcdwbzn4+e8= +cloud.google.com/go/recommendationengine v0.8.12/go.mod h1:A3c39mOVC4utWlwk+MpchvkZTM6MSJXm3KUwTQ47VzA= +cloud.google.com/go/recommender v1.12.8/go.mod h1:zoJL8kPJJotOoNU3D2fCXW33vhbyIPe0Sq7ObhYLnGM= +cloud.google.com/go/redis v1.16.5/go.mod h1:cWn6WHSEnmVZh9lJ9AN/UwDTtvlcT+TTRGvNIckUbG0= +cloud.google.com/go/resourcemanager v1.9.12/go.mod h1:unouv9x3+I+6kVeE10LGM3oJ8aQrUZganWnRchitbAM= +cloud.google.com/go/resourcesettings v1.7.5/go.mod h1:voqqKzYIrnoAqFKV6xk2qhgTnxzfGCJNOuBnHJEzcNU= +cloud.google.com/go/retail v1.17.5/go.mod h1:DSWPessLdnuvRH+N2FY+j1twyKtpRDKp4Y88dm7VqBw= +cloud.google.com/go/run v1.4.1/go.mod h1:gaXIpytRDfrJjb3pz9PRG2q2KUaDDDV+Uvmq6QRZH20= +cloud.google.com/go/scheduler v1.10.13/go.mod h1:lDJItkp2hNrCsHOBtVExCzjXBzK9WI3yKNg713/OU4s= +cloud.google.com/go/secretmanager v1.14.0/go.mod h1:q0hSFHzoW7eRgyYFH8trqEFavgrMeiJI4FETNN78vhM= +cloud.google.com/go/security v1.17.5/go.mod h1:MA8w7SbQAQO9CQ9r0R7HR0F7g1AJoqx87SFLpapq3OU= +cloud.google.com/go/securitycenter v1.34.0/go.mod h1:7esjYVxn7k0nm02CnLNueFWD40FH0eunhookSEUalSs= +cloud.google.com/go/servicedirectory v1.11.12/go.mod h1:A0mXC1awKEK5alkG7p3hxaHtb5SSPqAdeWx09RTIOGY= +cloud.google.com/go/shell v1.7.12/go.mod h1:QxxwQMvXqDUTYgMwbO7Y2Z6rojGzA7q64aQTCEj7xfM= +cloud.google.com/go/spanner v1.67.0/go.mod h1:Um+TNmxfcCHqNCKid4rmAMvoe/Iu1vdz6UfxJ9GPxRQ= +cloud.google.com/go/speech v1.24.1/go.mod h1:th/IKNidPLzrbaEiKLIhTv/oTGADe4r4bzxZvYG62EE= cloud.google.com/go/storage v1.43.0 h1:CcxnSohZwizt4LCzQHWvBf1/kvtHUn7gk9QERXPyXFs= cloud.google.com/go/storage v1.43.0/go.mod h1:ajvxEa7WmZS1PxvKRq4bq0tFT3vMd502JwstCcYv0Q0= -cloud.google.com/go/storagetransfer v1.10.10/go.mod h1:8+nX+WgQ2ZJJnK8e+RbK/zCXk8T7HdwyQAJeY7cEcm0= -cloud.google.com/go/talent v1.6.12/go.mod h1:nT9kNVuJhZX2QgqKZS6t6eCWZs5XEBYRBv6bIMnPmo4= -cloud.google.com/go/texttospeech v1.7.11/go.mod h1:Ua125HU+WT2IkIo5MzQtuNpNEk72soShJQVdorZ1SAE= -cloud.google.com/go/tpu v1.6.11/go.mod h1:W0C4xaSj1Ay3VX/H96FRvLt2HDs0CgdRPVI4e7PoCDk= -cloud.google.com/go/trace v1.10.12/go.mod h1:tYkAIta/gxgbBZ/PIzFxSH5blajgX4D00RpQqCG/GZs= +cloud.google.com/go/storagetransfer v1.10.11/go.mod h1:AMAR/PTS5yKPp1FHP6rk3eJYGmHF14vQYiHddcIgoOA= +cloud.google.com/go/talent v1.6.13/go.mod h1:jqjQzIF7ZPCxFSdsfhgUF0wGB+mbytYzyUqaHLiQcQg= +cloud.google.com/go/texttospeech v1.7.12/go.mod h1:B1Xck47Mhy/PJMnvrLkv0gfKGinGP78c0XFZjWB7TdY= +cloud.google.com/go/tpu v1.6.12/go.mod h1:IFJa2vI7gxF6fypOQXYmbuFwKLsde4zVwcv1p9zhOqY= +cloud.google.com/go/trace v1.11.0/go.mod h1:Aiemdi52635dBR7o3zuc9lLjXo3BwGaChEjCa3tJNmM= cloud.google.com/go/translate v1.10.3/go.mod h1:GW0vC1qvPtd3pgtypCv4k4U8B7EdgK9/QEF2aJEUovs= -cloud.google.com/go/translate v1.10.7/go.mod h1:mH/+8tvcItuy1cOWqU+/Y3iFHgkVUObNIQYI/kiFFiY= -cloud.google.com/go/video v1.22.0/go.mod h1:CxPshUNAb1ucnzbtruEHlAal9XY+SPG2cFqC/woJzII= -cloud.google.com/go/videointelligence v1.11.11/go.mod h1:dab2Ca3AXT6vNJmt3/6ieuquYRckpsActDekLcsd6dU= -cloud.google.com/go/vision/v2 v2.8.6/go.mod h1:G3v0uovxCye3u369JfrHGY43H6u/IQ08x9dw5aVH8yY= -cloud.google.com/go/vmmigration v1.7.11/go.mod h1:PmD1fDB0TEHGQR1tDZt9GEXFB9mnKKalLcTVRJKzcQA= -cloud.google.com/go/vmwareengine v1.2.0/go.mod h1:rPjCHu6hG9N8d6PhkoDWFkqL9xpbFY+ueVW+0pNFbZg= -cloud.google.com/go/vpcaccess v1.7.11/go.mod h1:a2cuAiSCI4TVK0Dt6/dRjf22qQvfY+podxst2VvAkcI= -cloud.google.com/go/webrisk v1.9.11/go.mod h1:mK6M8KEO0ZI7VkrjCq3Tjzw4vYq+3c4DzlMUDVaiswE= -cloud.google.com/go/websecurityscanner v1.6.11/go.mod h1:vhAZjksELSg58EZfUQ1BMExD+hxqpn0G0DuyCZQjiTg= -cloud.google.com/go/workflows v1.12.10/go.mod h1:RcKqCiOmKs8wFUEf3EwWZPH5eHc7Oq0kamIyOUCk0IE= -code.cloudfoundry.org/bytefmt v0.1.0 h1:NmVhaUPBO59QQpt5vwYW8crDUksCnvTCQi+Q6uOeLwM= -code.cloudfoundry.org/bytefmt v0.1.0/go.mod h1:eF2ZbltNI7Pv+8Cuyeksu9up5FN5konuH0trDJBuscw= +cloud.google.com/go/translate v1.11.0/go.mod h1:UFNHzrfcEo/ZCmA5SveVqxh0l57BP27HCvroN5o59FI= +cloud.google.com/go/video v1.22.1/go.mod h1:+AYF4e9kqQhra0AfKPoOOIUK0Ho7BquOWQK+Te+Qnns= +cloud.google.com/go/videointelligence v1.11.12/go.mod h1:dQlDAFtTwsZi3UI+03NVF4XQoarx0VU5/IKMLyVyC2E= +cloud.google.com/go/vision/v2 v2.8.7/go.mod h1:4ADQGbgAAvEDn/2I6XLeBN6mCUq6D44bfjWaqQc6iYU= +cloud.google.com/go/vmmigration v1.7.12/go.mod h1:Fb6yZsMdgFUo3wdDc7vK75KmBzXkY1Tio/053vuvCXU= +cloud.google.com/go/vmwareengine v1.2.1/go.mod h1:OE5z8qJdTiPpSeWunFenN/RMF7ymRgI0HvJ/c7Zl5U0= +cloud.google.com/go/vpcaccess v1.7.12/go.mod h1:Bt9j9aqlNDj1xW5uMNrHyhpc61JZgttbQRecG9xm1cE= +cloud.google.com/go/webrisk v1.9.12/go.mod h1:YaAgE2xKzIN8yQNUspTTeZbvdcifSJh+wcMyXmp8fgg= +cloud.google.com/go/websecurityscanner v1.6.12/go.mod h1:9WFCBNpS0EIIhQaqiNC3ezZ48qisGPh3Ekz6T2n9Ioc= +cloud.google.com/go/workflows v1.12.11/go.mod h1:0cYsbMDyqr/1SbEt1DfN+S+mI2AAnVrT7+Hrh7qaxZ0= +code.cloudfoundry.org/bytefmt v0.3.0 h1:YXk7eONhKg0rbtf2qgYxMnY1jFF7LTKSIGBcffEOlYU= +code.cloudfoundry.org/bytefmt v0.3.0/go.mod h1:k3jf4RMghgxbifF8p9eCFQnuLtTLaqU2ufkwYC06gio= dmitri.shuralyov.com/gpu/mtl v0.0.0-20201218220906-28db891af037/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= dmitri.shuralyov.com/gpu/mtl v0.0.0-20221208032759-85de2813cf6b/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= eliasnaur.com/font v0.0.0-20230308162249-dd43949cb42d/go.mod h1:OYVuxibdk9OSLX8vAqydtRPP87PyTFcT9uH3MlEGBQA= @@ -194,8 +194,8 @@ github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ github.com/GoogleCloudPlatform/grpc-gcp-go/grpcgcp v1.5.0/go.mod h1:dppbR7CwXD4pgtV9t3wD1812RaLDcBjtblcDF5f1vI0= github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c/go.mod h1:X0CRv0ky0k6m906ixxpzmDRLvX58TFUKS2eePweuyxk= github.com/Kodeworks/golang-image-ico v0.0.0-20141118225523-73f0f4cfade9/go.mod h1:7uhhqiBaR4CpN0k9rMjOtjpcfGd6DG2m04zQxKnWQ0I= -github.com/ajstarks/deck v0.0.0-20240814155529-0478e0c25be8/go.mod h1:5o5HzZ3nUiOivE0SPQepE7oNquDd+9yip0PtlFpq888= -github.com/ajstarks/deck/generate v0.0.0-20240814155529-0478e0c25be8/go.mod h1:al/X+Mdfx3esXeGnnIVn5aYB6SfwTu+9T0u4EXmKJuk= +github.com/ajstarks/deck v0.0.0-20240820134305-55491d041044/go.mod h1:5o5HzZ3nUiOivE0SPQepE7oNquDd+9yip0PtlFpq888= +github.com/ajstarks/deck/generate v0.0.0-20240820134305-55491d041044/go.mod h1:al/X+Mdfx3esXeGnnIVn5aYB6SfwTu+9T0u4EXmKJuk= github.com/ajstarks/fc v0.0.0-20230606144319-ef5d5cb73a3d/go.mod h1:Qp3TfzbBiIjHwDxIpu+g9nYfNw+xXF2Yqp4WmMlTtwM= github.com/ajstarks/openvg v0.0.0-20191008131700-c6885d824eb8/go.mod h1:jpZHIkd4sQEgrzshrUQrRfv5OUMMq0w/Q1yK6ZYhUlk= github.com/ajstarks/svgo v0.0.0-20211024235047-1546f124cd8b h1:slYM766cy2nI3BwyRiyQj/Ud48djTMtMebDqepE95rw= @@ -222,14 +222,14 @@ github.com/aws/aws-sdk-go-v2 v1.30.4 h1:frhcagrVNrzmT95RJImMHgabt99vkXGslubDaDag github.com/aws/aws-sdk-go-v2 v1.30.4/go.mod h1:CT+ZPWXbYrci8chcARI3OmI/qgd+f6WtuLOoaIA8PR0= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.4 h1:70PVAiL15/aBMh5LThwgXdSQorVr91L127ttckI9QQU= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.4/go.mod h1:/MQxMqci8tlqDH+pjmoLu1i0tbWCUP1hhyMRuFxpQCw= -github.com/aws/aws-sdk-go-v2/config v1.27.28 h1:OTxWGW/91C61QlneCtnD62NLb4W616/NM1jA8LhJqbg= -github.com/aws/aws-sdk-go-v2/config v1.27.28/go.mod h1:uzVRVtJSU5EFv6Fu82AoVFKozJi2ZCY6WRCXj06rbvs= -github.com/aws/aws-sdk-go-v2/credentials v1.17.28 h1:m8+AHY/ND8CMHJnPoH7PJIRakWGa4gbfbxuY9TGTUXM= -github.com/aws/aws-sdk-go-v2/credentials v1.17.28/go.mod h1:6TF7dSc78ehD1SL6KpRIPKMA1GyyWflIkjqg+qmf4+c= +github.com/aws/aws-sdk-go-v2/config v1.27.30 h1:AQF3/+rOgeJBQP3iI4vojlPib5X6eeOYoa/af7OxAYg= +github.com/aws/aws-sdk-go-v2/config v1.27.30/go.mod h1:yxqvuubha9Vw8stEgNiStO+yZpP68Wm9hLmcm+R/Qk4= +github.com/aws/aws-sdk-go-v2/credentials v1.17.29 h1:CwGsupsXIlAFYuDVHv1nnK0wnxO0wZ/g1L8DSK/xiIw= +github.com/aws/aws-sdk-go-v2/credentials v1.17.29/go.mod h1:BPJ/yXV92ZVq6G8uYvbU0gSl8q94UB63nMT5ctNO38g= github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.12 h1:yjwoSyDZF8Jth+mUk5lSPJCkMC0lMy6FaCD51jm6ayE= github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.12/go.mod h1:fuR57fAgMk7ot3WcNQfb6rSEn+SUffl7ri+aa8uKysI= -github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.11 h1:FEDZD/Axt5tKSkPAs967KZ++MkvYdBqr0a+cetRbjLM= -github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.11/go.mod h1:dvlsbA32KfvCzqwTiX7maABgFek2RyUuYEJ3kyn/PmQ= +github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.14 h1:dQa4KkoEVgk3oLL9IeoW9qrXijyQ6lWa+DX6Vn32Lhw= +github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.14/go.mod h1:aRKW0B+zH8J6cz3FFiQ9JbUQc7UroLx6lwfvNqIsPOs= github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.16 h1:TNyt/+X43KJ9IJJMjKfa3bNTiZbUP7DeCxfbTROESwY= github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.16/go.mod h1:2DwJF39FlNAUiX5pAc0UNeiz16lK2t7IaFcm0LFHEgc= github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.16 h1:jYfy8UPmd+6kJW5YhY0L1/KftReOGxI/4NtVSTh9O/I= @@ -246,14 +246,14 @@ github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.18 h1:tJ5RnkHC github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.18/go.mod h1:++NHzT+nAF7ZPrHPsA+ENvsXkOO8wEu+C6RXltAG4/c= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.16 h1:jg16PhLPUiHIj8zYIW6bqzeQSuHVEiWnGA0Brz5Xv2I= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.16/go.mod h1:Uyk1zE1VVdsHSU7096h/rwnXDzOzYQVl+FNPhPw7ShY= -github.com/aws/aws-sdk-go-v2/service/s3 v1.59.0 h1:Cso4Ev/XauMVsbwdhYEoxg8rxZWw43CFqqaPB5w3W2c= -github.com/aws/aws-sdk-go-v2/service/s3 v1.59.0/go.mod h1:BSPI0EfnYUuNHPS0uqIo5VrRwzie+Fp+YhQOUs16sKI= +github.com/aws/aws-sdk-go-v2/service/s3 v1.60.1 h1:mx2ucgtv+MWzJesJY9Ig/8AFHgoE5FwLXwUVgW/FGdI= +github.com/aws/aws-sdk-go-v2/service/s3 v1.60.1/go.mod h1:BSPI0EfnYUuNHPS0uqIo5VrRwzie+Fp+YhQOUs16sKI= github.com/aws/aws-sdk-go-v2/service/sso v1.22.5 h1:zCsFCKvbj25i7p1u94imVoO447I/sFv8qq+lGJhRN0c= github.com/aws/aws-sdk-go-v2/service/sso v1.22.5/go.mod h1:ZeDX1SnKsVlejeuz41GiajjZpRSWR7/42q/EyA/QEiM= github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.4 h1:yiwVzJW2ZxZTurVbYWA7QOrAaCYQR72t0wrSBfoesUE= github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.4/go.mod h1:0oxfLkpz3rQ/CHlx5hB7H69YUpFiI1tql6Q6Ne+1bCw= -github.com/aws/aws-sdk-go-v2/service/sts v1.30.4 h1:iAckBT2OeEK/kBDyN/jDtpEExhjeeA/Im2q4X0rJZT8= -github.com/aws/aws-sdk-go-v2/service/sts v1.30.4/go.mod h1:vmSqFK+BVIwVpDAGZB3CoCXHzurt4qBE8lf+I/kRTh0= +github.com/aws/aws-sdk-go-v2/service/sts v1.30.5 h1:OMsEmCyz2i89XwRwPouAJvhj81wINh+4UK+k/0Yo/q8= +github.com/aws/aws-sdk-go-v2/service/sts v1.30.5/go.mod h1:vmSqFK+BVIwVpDAGZB3CoCXHzurt4qBE8lf+I/kRTh0= github.com/aws/smithy-go v1.20.4 h1:2HK1zBdPgRbjFOHlfeQZfpC4r72MOb9bZkiFwggKO+4= github.com/aws/smithy-go v1.20.4/go.mod h1:irrKGvNn1InZwb2d7fkIRNucdfwR8R+Ts3wxYa/cJHg= github.com/benbjohnson/clock v1.3.5 h1:VvXlSJBzZpA/zum6Sj74hxwYI2DIxRWuNIoXAzHZz5o= @@ -275,8 +275,8 @@ github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwys github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObkaSkeBlk= github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8= github.com/cncf/udpa/go v0.0.0-20220112060539-c52dc94e7fbe/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= -github.com/cncf/xds/go v0.0.0-20240723142845-024c85f92f20 h1:N+3sFI5GUjRKBi+i0TxYVST9h4Ie192jJWpHvthBBgg= -github.com/cncf/xds/go v0.0.0-20240723142845-024c85f92f20/go.mod h1:W+zGtBO5Y1IgJhy4+A9GOqVhqLpfZi+vwmdNXUehLA8= +github.com/cncf/xds/go v0.0.0-20240822171458-6449f94b4d59 h1:fLZ97KE86ELjEYJCEUVzmbhfzDxHHGwBrDVMd4XL6Bs= +github.com/cncf/xds/go v0.0.0-20240822171458-6449f94b4d59/go.mod h1:W+zGtBO5Y1IgJhy4+A9GOqVhqLpfZi+vwmdNXUehLA8= github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/creack/pty v1.1.23 h1:4M6+isWdcStXEf15G/RbrMPOQj1dZ7HPZCGwE4kOeP0= github.com/creack/pty v1.1.23/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE= @@ -397,8 +397,8 @@ github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM= github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/google/btree v1.1.2 h1:xf4v41cLI2Z6FxbKm+8Bu+m8ifhj15JuZ9sa0jZCMUU= -github.com/google/btree v1.1.2/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4= +github.com/google/btree v1.1.3 h1:CVpQJjYgC4VbzxeGVHfvZrv1ctoYCAI8vbl07Fcxlyg= +github.com/google/btree v1.1.3/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4= github.com/google/flatbuffers v23.5.26+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= github.com/google/gnostic-models v0.6.8 h1:yo/ABAfM5IMRsS1VnXjTBvUb61tFIHozhlYvRgGre9I= github.com/google/gnostic-models v0.6.8/go.mod h1:5n7qKqH0f5wFt+aWF8CW6pZLLNOfYuF5OpfBSENuI8U= @@ -556,8 +556,8 @@ github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY= github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc= github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= -github.com/onsi/ginkgo/v2 v2.20.0 h1:PE84V2mHqoT1sglvHc8ZdQtPcwmvvt29WLEEO3xmdZw= -github.com/onsi/ginkgo/v2 v2.20.0/go.mod h1:lG9ey2Z29hR41WMVthyJBGUBcBhGOtoPF2VFMvBXFCI= +github.com/onsi/ginkgo/v2 v2.20.1 h1:YlVIbqct+ZmnEph770q9Q7NVAz4wwIiVNahee6JyUzo= +github.com/onsi/ginkgo/v2 v2.20.1/go.mod h1:lG9ey2Z29hR41WMVthyJBGUBcBhGOtoPF2VFMvBXFCI= github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k= github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY= github.com/peterbourgon/diskv v2.0.1+incompatible h1:UBdAOUP5p4RWqPBg048CAvpKN+vxiaj6gdUUzhl4XmI= @@ -577,8 +577,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prashantv/gostub v1.1.0 h1:BTyx3RfQjRHnUWaGF9oQos79AlQ5k8WNktv7VGvVH4g= github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P1IAHhP5U= -github.com/prometheus/client_golang v1.20.0 h1:jBzTZ7B099Rg24tny+qngoynol8LtVYlA2bqx3vEloI= -github.com/prometheus/client_golang v1.20.0/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE= +github.com/prometheus/client_golang v1.20.2 h1:5ctymQzZlyOON1666svgwn3s6IKWgfbjsejTMiXIyjg= +github.com/prometheus/client_golang v1.20.2/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE= github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E= github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY= github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc= @@ -644,31 +644,31 @@ github.com/zeebo/assert v1.3.1/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0= github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA= go.einride.tech/aip v0.67.1/go.mod h1:ZGX4/zKw8dcgzdLsrvpOOGxfxI2QSk12SlP7d6c0/XI= -go.etcd.io/bbolt v1.3.10 h1:+BqfJTcCzTItrop8mq/lbzL8wSGtj94UO/3U31shqG0= -go.etcd.io/bbolt v1.3.10/go.mod h1:bK3UQLPJZly7IlNmV7uVHJDxfe5aK9Ll93e/74Y9oEQ= +go.etcd.io/bbolt v1.3.11 h1:yGEzV1wPz2yVCLsD8ZAiGHhHVlczyC9d1rP43/VCRJ0= +go.etcd.io/bbolt v1.3.11/go.mod h1:dksAq7YMXoljX0xu6VF5DMZGbhYYoLUalEiSySYAS4I= 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.53.0 h1:9G6E0TXzGFVfTnawRzrPl83iHOAV7L8NJiR8RSGYV1g= -go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.53.0/go.mod h1:azvtTADFQJA8mX80jIH/akaE7h+dbm/sVuaHqN13w74= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.54.0 h1:r6I7RJCN86bpD/FQwedZ0vSixDpwuWREjW9oRMsmqDc= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.54.0/go.mod h1:B9yO6b04uB80CzjedvewuqDhxJxi11s7/GtiGa8bAjI= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0/go.mod h1:p8pYQP+m5XfbZm9fxtSKAbM6oIllS7s2AfxrChvc7iw= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0 h1:4K4tsIXefpVJtvA/8srF4V4y0akAoPHkIslgAkjixJA= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.53.0/go.mod h1:jjdQuTGVsXV4vSs+CJ2qYDeDPf9yIJV23qlIzBm73Vg= -go.opentelemetry.io/otel v1.28.0 h1:/SqNcYk+idO0CxKEUOtKQClMK/MimZihKYMruSMViUo= -go.opentelemetry.io/otel v1.28.0/go.mod h1:q68ijF8Fc8CnMHKyzqL6akLO46ePnjkgfIMIjUIX9z4= -go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.28.0 h1:U2guen0GhqH8o/G2un8f/aG/y++OuW6MyCo6hT9prXk= -go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.28.0/go.mod h1:yeGZANgEcpdx/WK0IvvRFC+2oLiMS2u4L/0Rj2M2Qr0= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0 h1:3Q/xZUyC1BBkualc9ROb4G8qkH90LXEIICcs5zv1OYY= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.28.0/go.mod h1:s75jGIWA9OfCMzF0xr+ZgfrB5FEbbV7UuYo32ahUiFI= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.28.0 h1:R3X6ZXmNPRR8ul6i3WgFURCHzaXjHdm0karRG/+dj3s= -go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.28.0/go.mod h1:QWFXnDavXWwMx2EEcZsf3yxgEKAqsxQ+Syjp+seyInw= -go.opentelemetry.io/otel/metric v1.28.0 h1:f0HGvSl1KRAU1DLgLGFjrwVyismPlnuU6JD6bOeuA5Q= -go.opentelemetry.io/otel/metric v1.28.0/go.mod h1:Fb1eVBFZmLVTMb6PPohq3TO9IIhUisDsbJoL/+uQW4s= -go.opentelemetry.io/otel/sdk v1.28.0 h1:b9d7hIry8yZsgtbmM0DKyPWMMUMlK9NEKuIG4aBqWyE= -go.opentelemetry.io/otel/sdk v1.28.0/go.mod h1:oYj7ClPUA7Iw3m+r7GeEjz0qckQRJK2B8zjcZEfu7Pg= -go.opentelemetry.io/otel/sdk/metric v1.28.0 h1:OkuaKgKrgAbYrrY0t92c+cC+2F6hsFNnCQArXCKlg08= -go.opentelemetry.io/otel/sdk/metric v1.28.0/go.mod h1:cWPjykihLAPvXKi4iZc1dpER3Jdq2Z0YLse3moQUCpg= -go.opentelemetry.io/otel/trace v1.28.0 h1:GhQ9cUuQGmNDd5BTCP2dAvv75RdMxEfTmYejp+lkx9g= -go.opentelemetry.io/otel/trace v1.28.0/go.mod h1:jPyXzNPg6da9+38HEwElrQiHlVMTnVfM3/yv2OlIHaI= +go.opentelemetry.io/otel v1.29.0 h1:PdomN/Al4q/lN6iBJEN3AwPvUiHPMlt93c8bqTG5Llw= +go.opentelemetry.io/otel v1.29.0/go.mod h1:N/WtXPs1CNCUEx+Agz5uouwCba+i+bJGFicT8SR4NP8= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.29.0 h1:k6fQVDQexDE+3jG2SfCQjnHS7OamcP73YMoxEVq5B6k= +go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.29.0/go.mod h1:t4BrYLHU450Zo9fnydWlIuswB1bm7rM8havDpWOJeDo= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.29.0 h1:dIIDULZJpgdiHz5tXrTgKIMLkus6jEFa7x5SOKcyR7E= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.29.0/go.mod h1:jlRVBe7+Z1wyxFSUs48L6OBQZ5JwH2Hg/Vbl+t9rAgI= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.29.0 h1:nSiV3s7wiCam610XcLbYOmMfJxB9gO4uK3Xgv5gmTgg= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.29.0/go.mod h1:hKn/e/Nmd19/x1gvIHwtOwVWM+VhuITSWip3JUDghj0= +go.opentelemetry.io/otel/metric v1.29.0 h1:vPf/HFWTNkPu1aYeIsc98l4ktOQaL6LeSoeV2g+8YLc= +go.opentelemetry.io/otel/metric v1.29.0/go.mod h1:auu/QWieFVWx+DmQOUMgj0F8LHWdgalxXqvp7BII/W8= +go.opentelemetry.io/otel/sdk v1.29.0 h1:vkqKjk7gwhS8VaWb0POZKmIEDimRCMsopNYnriHyryo= +go.opentelemetry.io/otel/sdk v1.29.0/go.mod h1:pM8Dx5WKnvxLCb+8lG1PRNIDxu9g9b9g59Qr7hfAAok= +go.opentelemetry.io/otel/sdk/metric v1.29.0 h1:K2CfmJohnRgvZ9UAj2/FhIf/okdWcNdBwe1m8xFXiSY= +go.opentelemetry.io/otel/sdk/metric v1.29.0/go.mod h1:6zZLdCl2fkauYoZIOn/soQIDSWFmNSRcICarHfuhNJQ= +go.opentelemetry.io/otel/trace v1.29.0 h1:J/8ZNK4XgR7a21DZUAsbF8pZ5Jcw1VhACmnYt39JTi4= +go.opentelemetry.io/otel/trace v1.29.0/go.mod h1:eHl3w0sp3paPkYstJOmAimxhiFXPg+MMTlEh3nsQgWQ= go.opentelemetry.io/proto/otlp v1.3.1 h1:TrMUixzpM0yuc/znrFTP9MMRh8trP93mkCiDVeXrui0= go.opentelemetry.io/proto/otlp v1.3.1/go.mod h1:0X1WI4de4ZsLrrJNLAQbFeLCm3T7yBkR0XqQ7niQU+8= go.starlark.net v0.0.0-20240725214946-42030a7cedce h1:YyGqCjZtGZJ+mRPaenEiB87afEO2MFRzLiJNZ0Z0bPw= @@ -689,14 +689,14 @@ gocloud.dev v0.39.0 h1:EYABYGhAalPUaMrbSKOr5lejxoxvXj99nE8XFtsDgds= gocloud.dev v0.39.0/go.mod h1:drz+VyYNBvrMTW0KZiBAYEdl8lbNZx+OQ7oQvdrFmSQ= golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw= golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54= -golang.org/x/exp v0.0.0-20240808152545-0cdaa3abc0fa h1:ELnwvuAXPNtPk1TJRuGkI9fDTwym6AYBu0qzT8AcHdI= -golang.org/x/exp v0.0.0-20240808152545-0cdaa3abc0fa/go.mod h1:akd2r19cwCdwSwWeIdzYQGa/EZZyqcOdwWiwj5L5eKQ= +golang.org/x/exp v0.0.0-20240823005443-9b4947da3948 h1:kx6Ds3MlpiUHKj7syVnbp57++8WpuKPcR5yjLBjvLEA= +golang.org/x/exp v0.0.0-20240823005443-9b4947da3948/go.mod h1:akd2r19cwCdwSwWeIdzYQGa/EZZyqcOdwWiwj5L5eKQ= golang.org/x/exp/shiny v0.0.0-20220827204233-334a2380cb91/go.mod h1:VjAR7z0ngyATZTELrBSkxOOHhhlnVUxDye4mcjx5h/8= golang.org/x/exp/shiny v0.0.0-20230801115018-d63ba01acd4b/go.mod h1:UH99kUObWAZkDnWqppdQe5ZhPYESUw8I0zVV1uWBR+0= golang.org/x/exp/shiny v0.0.0-20230817173708-d852ddb80c63/go.mod h1:UH99kUObWAZkDnWqppdQe5ZhPYESUw8I0zVV1uWBR+0= golang.org/x/exp/shiny v0.0.0-20240707233637-46b078467d37/go.mod h1:3F+MieQB7dRYLTmnncoFbb1crS5lfQoTfDgQy6K4N0o= -golang.org/x/exp/typeparams v0.0.0-20240808152545-0cdaa3abc0fa h1:54T+HVkPu4D3lltpEHyI3Fs2pG/GqjGkXLgyKOmifXk= -golang.org/x/exp/typeparams v0.0.0-20240808152545-0cdaa3abc0fa/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk= +golang.org/x/exp/typeparams v0.0.0-20240823005443-9b4947da3948 h1:mwwJFsdsQzu/zhRdxEXmpMvRMnAR6QpbAXx3cNooEf0= +golang.org/x/exp/typeparams v0.0.0-20240823005443-9b4947da3948/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk= golang.org/x/image v0.19.0 h1:D9FX4QWkLfkeqaC62SonffIIuYdOk/UE2XKUBgRIBIQ= golang.org/x/image v0.19.0/go.mod h1:y0zrRqlQRWQ5PXaYCOMLTW2fpsxZ8Qh9I/ohnInJEys= golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= @@ -730,16 +730,16 @@ gonum.org/v1/hdf5 v0.0.0-20210714002203-8c5d23bc6946 h1:vJpL69PeUullhJyKtTjHjENE gonum.org/v1/hdf5 v0.0.0-20210714002203-8c5d23bc6946/go.mod h1:BQUWDHIAygjdt1HnUPQ0eWqLN2n5FwJycrpYUVUOx2I= 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.192.0 h1:PljqpNAfZaaSpS+TnANfnNAXKdzHM/B9bKhwRlo7JP0= -google.golang.org/api v0.192.0/go.mod h1:9VcphjvAxPKLmSxVSzPlSRXy/5ARMEw5bf58WoVXafQ= +google.golang.org/api v0.194.0 h1:dztZKG9HgtIpbI35FhfuSNR/zmaMVdxNlntHj1sIS4s= +google.golang.org/api v0.194.0/go.mod h1:AgvUFdojGANh3vI+P7EVnxj3AISHllxGCJSFmggmnd0= google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds= -google.golang.org/genproto v0.0.0-20240814211410-ddb44dafa142 h1:oLiyxGgE+rt22duwci1+TG7bg2/L1LQsXwfjPlmuJA0= -google.golang.org/genproto v0.0.0-20240814211410-ddb44dafa142/go.mod h1:G11eXq53iI5Q+kyNOmCvnzBaxEA2Q/Ik5Tj7nqBE8j4= -google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142 h1:wKguEg1hsxI2/L3hUYrpo1RVi48K+uTyzKqprwLXsb8= -google.golang.org/genproto/googleapis/api v0.0.0-20240814211410-ddb44dafa142/go.mod h1:d6be+8HhtEtucleCbxpPW9PA9XwISACu8nvpPqF0BVo= -google.golang.org/genproto/googleapis/bytestream v0.0.0-20240730163845-b1a4ccb954bf/go.mod h1:5/MT647Cn/GGhwTpXC7QqcaR5Cnee4v4MKCU1/nwnIQ= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 h1:e7S5W7MGGLaSu8j3YjdezkZ+m1/Nm0uRVRMEMGk26Xs= -google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= +google.golang.org/genproto v0.0.0-20240823204242-4ba0660f739c h1:TYOEhrQMrNDTAd2rX9m+WgGr8Ku6YNuj1D7OX6rWSok= +google.golang.org/genproto v0.0.0-20240823204242-4ba0660f739c/go.mod h1:2rC5OendXvZ8wGEo/cSLheztrZDZaSoHanUcd1xtZnw= +google.golang.org/genproto/googleapis/api v0.0.0-20240823204242-4ba0660f739c h1:e0zB268kOca6FbuJkYUGxfwG4DKFZG/8DLyv9Zv66cE= +google.golang.org/genproto/googleapis/api v0.0.0-20240823204242-4ba0660f739c/go.mod h1:fO8wJzT2zbQbAjbIoos1285VfEIYKDDY+Dt+WpTkh6g= +google.golang.org/genproto/googleapis/bytestream v0.0.0-20240814211410-ddb44dafa142/go.mod h1:gQizMG9jZ0L2ADJaM+JdZV4yTCON/CQpnHRPoM+54w4= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240823204242-4ba0660f739c h1:Kqjm4WpoWvwhMPcrAczoTyMySQmYa9Wy2iL6Con4zn8= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240823204242-4ba0660f739c/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc= google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ= google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= @@ -769,12 +769,12 @@ k8s.io/client-go v0.30.3 h1:bHrJu3xQZNXIi8/MoxYtZBBWQQXwy16zqJwloXXfD3k= k8s.io/client-go v0.30.3/go.mod h1:8d4pf8vYu665/kUbsxWAQ/JDBNWqfFeZnvFiVdmx89U= k8s.io/klog/v2 v2.130.1 h1:n9Xl7H1Xvksem4KFG4PYbdQCQxqc/tTUyrgXaOhHSzk= k8s.io/klog/v2 v2.130.1/go.mod h1:3Jpz1GvMt720eyJH1ckRHK1EDfpxISzJ7I9OYgaDtPE= -k8s.io/kube-openapi v0.0.0-20240816214639-573285566f34 h1:/amS69DLm09mtbFtN3+LyygSFohnYGMseF8iv+2zulg= -k8s.io/kube-openapi v0.0.0-20240816214639-573285566f34/go.mod h1:G0W3eI9gG219NHRq3h5uQaRBl4pj4ZpwzRP5ti8y770= +k8s.io/kube-openapi v0.0.0-20240822171749-76de80e0abd9 h1:y+4z/s0h3R97P/o/098DSjlpyNpHzGirNPlTL+GHdqY= +k8s.io/kube-openapi v0.0.0-20240822171749-76de80e0abd9/go.mod h1:s4yb9FXajAVNRnxSB5Ckpr/oq2LP4mKSMWeZDVppd30= k8s.io/metrics v0.30.3 h1:gKCpte5zykrOmQhZ8qmsxyJslMdiLN+sqbBfIWNpbGM= k8s.io/metrics v0.30.3/go.mod h1:W06L2nXRhOwPkFYDJYWdEIS3u6JcJy3ebIPYbndRs6A= -k8s.io/utils v0.0.0-20240711033017-18e509b52bc8 h1:pUdcCO1Lk/tbT5ztQWOBi5HBgbBP1J8+AsQnQCKsi8A= -k8s.io/utils v0.0.0-20240711033017-18e509b52bc8/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= +k8s.io/utils v0.0.0-20240821151609-f90d01438635 h1:2wThSvJoW/Ncn9TmQEYXRnevZXi2duqHWf5OX9S3zjI= +k8s.io/utils v0.0.0-20240821151609-f90d01438635/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0= lukechampine.com/uint128 v1.1.1/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk= lukechampine.com/uint128 v1.2.0/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk= lukechampine.com/uint128 v1.3.0/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk= diff --git a/hack/cspell/main.go b/hack/cspell/main.go new file mode 100644 index 0000000000..c14dd4fa50 --- /dev/null +++ b/hack/cspell/main.go @@ -0,0 +1,336 @@ +package main + +import ( + "bufio" + "cmp" + "encoding/json" + "flag" + "fmt" + "os" + "regexp" + "slices" + "strings" + "sync" +) + +type CSpellConfig struct { + Version string `json:"version"` + Language string `json:"language"` + Import []string `json:"import"` + IgnorePaths []string `json:"ignorePaths"` + Patterns []PatternEntry `json:"patterns,omitempty"` + IgnoreRegExpList []string `json:"ignoreRegExpList,omitempty"` + IgnoreWords []string `json:"ignoreWords,omitempty"` + IgnoreWordsMap map[string][]string `json:"ignoreWordsMap,omitempty"` +} + +type PatternEntry struct { + Name string `json:"name"` + Pattern string `json:"pattern"` +} + +type Override struct { + Files []string `json:"files"` + Words []string `json:"words"` +} + +var ( + mandatoryImports = []string{ + "@cspell/dict-cpp/cspell-ext.json", + "@cspell/dict-docker/cspell-ext.json", + "@cspell/dict-en_us/cspell-ext.json", + "@cspell/dict-fullstack/cspell-ext.json", + "@cspell/dict-git/cspell-ext.json", + "@cspell/dict-golang/cspell-ext.json", + "@cspell/dict-k8s/cspell-ext.json", + "@cspell/dict-makefile/cspell-ext.json", + "@cspell/dict-markdown/cspell-ext.json", + "@cspell/dict-npm/cspell-ext.json", + "@cspell/dict-public-licenses/cspell-ext.json", + "@cspell/dict-rust/cspell-ext.json", + "@cspell/dict-shell/cspell-ext.json", + } + + mandatoryIgnorePaths = []string{ + "**/*.ai", + "**/*.drawio", + "**/*.hdf5", + "**/*.key", + "**/*.lock", + "**/*.log", + "**/*.md5", + "**/*.pack", + "**/*.pdf", + "**/*.pem", + "**/*.png", + "**/*.sum", + "**/*.svg", + "**/.cspell.json", + "**/.git/objects/**", + "**/cmd/agent/core/faiss/faiss", + "**/cmd/agent/core/ngt/ngt", + "**/cmd/agent/sidecar/sidecar", + "**/cmd/discoverer/k8s/discoverer", + "**/cmd/gateway/filter/filter", + "**/cmd/gateway/lb/lb", + "**/cmd/gateway/mirror/mirror", + "**/cmd/index/job/correction/index-correction", + "**/cmd/index/job/creation/index-creation", + "**/cmd/index/job/readreplica/rotate/readreplica-rotate", + "**/cmd/index/job/save/index-save", + "**/cmd/index/operator/index-operator", + "**/cmd/manager/index/index", + "**/cmd/tools/benchmark/job/job", + "**/cmd/tools/benchmark/operator/operator", + "**/cmd/tools/cli/loadtest/loadtest", + "**/hack/cspell/**", + "**/internal/core/algorithm/ngt/assets/index", + "**/internal/test/data/agent/ngt/validIndex", + } + suffixes = []string{ + "addr", + "addrs", + "buf", + "cancel", + "cfg", + "ch", + "cnt", + "conf", + "conn", + "ctx", + "dim", + "dur", + "env", + "err", + "error", + "errors", + "errs", + "idx", + "len", + "mu", + "opt", + "opts", + "pool", + "req", + "res", + "size", + "vec", + } + + sufReg = regexp.MustCompile(fmt.Sprintf("(%s)$", strings.Join(suffixes, "|"))) + + prexp = regexp.MustCompile(`Unknown word \((.*?)\) Suggestions`) +) + +func extractLine(line string) (filePath, word string, ok bool) { + filePath, line, ok = strings.Cut(line, ":") + if !ok || len(filePath) == 0 { + return "", "", false + } + _, s, ok := strings.Cut(line, " - ") + if ok { + line = s + } + matches := prexp.FindStringSubmatch(line) + if len(matches) > 1 { + return filePath, matches[1], true + } + return "", "", false +} + +func parseCspellResult(filePath string, th int) (map[string][]string, map[string]bool, error) { + file, err := os.Open(filePath) + if err != nil { + return nil, nil, fmt.Errorf("could not open file: %w", err) + } + defer file.Close() + + var ( + wg sync.WaitGroup + mu sync.Mutex + ) + wordsByFile := make(map[string][]string) + filesByWord := make(map[string][]string) + scanner := bufio.NewScanner(file) + for scanner.Scan() { + line := scanner.Text() + wg.Add(1) + go func() { + defer wg.Done() + // Extract the unknown word + if path, word, ok := extractLine(line); ok { + if sufReg.MatchString(word) { + return + } + lword := strings.ToLower(word) + mu.Lock() + w, ok := wordsByFile[path] + if !ok || w == nil { + w = make([]string, 0, 2) + } + wordsByFile[path] = append(w, word) + + f, ok := filesByWord[word] + if !ok || f == nil { + f = make([]string, 0, 2) + } + filesByWord[word] = append(f, path) + + if word != lword { + f, ok = filesByWord[lword] + if !ok || f == nil { + f = make([]string, 0, 2) + } + filesByWord[lword] = append(f, path) + } + mu.Unlock() + } + }() + } + + wg.Wait() + + globalWords := make(map[string]bool) + for word, files := range filesByWord { + lword := strings.ToLower(word) + if word != lword { + lfiles, ok := filesByWord[lword] + if ok { + files = append(files, lfiles...) + slices.Sort(files) + files = slices.Compact(files) + if len(files) >= th { + globalWords[lword] = true + globalWords[word] = true + } + } + } else if len(files) >= th { + globalWords[word] = true + } + } + + if err := scanner.Err(); err != nil { + return nil, nil, fmt.Errorf("error reading file: %w", err) + } + + return wordsByFile, globalWords, nil +} + +func loadConfig(path string) (config *CSpellConfig, err error) { + file, err := os.Open(path) + if err != nil { + return nil, err + } + defer file.Close() + + config = new(CSpellConfig) + err = json.NewDecoder(file).Decode(config) + if err != nil { + return nil, err + } + return config, nil +} + +func saveConfig(path string, config *CSpellConfig) error { + file, err := os.Create(path) + if err != nil { + return err + } + defer file.Close() + + encoder := json.NewEncoder(file) + encoder.SetIndent("", " ") + return encoder.Encode(config) +} + +func addPatterns(config *CSpellConfig) { + if config.Patterns == nil { + config.Patterns = make([]PatternEntry, 0, len(suffixes)) + } + if config.IgnoreRegExpList == nil { + config.IgnoreRegExpList = make([]string, 0, len(suffixes)) + } + for _, suffix := range suffixes { + pat := fmt.Sprintf("/\\b\\w*%s\\b/", suffix) + name := fmt.Sprintf("Ignore_%s_suffix", suffix) + config.Patterns = append(config.Patterns, PatternEntry{ + Name: name, + Pattern: pat, + }) + config.IgnoreRegExpList = append(config.IgnoreRegExpList, name) + } + slices.SortFunc(config.Patterns, func(left, right PatternEntry) int { + return cmp.Compare(left.Name, right.Name) + }) + config.Patterns = slices.CompactFunc(config.Patterns, func(left, right PatternEntry) bool { + return left.Name == right.Name + }) + slices.Sort(config.IgnoreRegExpList) + config.IgnoreRegExpList = slices.Compact(config.IgnoreRegExpList) +} + +func main() { + configPath := flag.String("config", ".cspell.json", "Path to the existing .cspell.json file") + outputPath := flag.String("output", "", "Path to the cspell output log") + threshold := flag.Int("threshold", 5, "Threshold for declaring global words") + + flag.Parse() + + if *outputPath == "" { + fmt.Println("Error: output path is required") + os.Exit(1) + } + + config, err := loadConfig(*configPath) + if err != nil || config == nil { + config = new(CSpellConfig) + } + config.Import = mandatoryImports + config.IgnorePaths = mandatoryIgnorePaths + config.Version = "0.2" + config.Language = "en" + + addPatterns(config) + + wordsByFile, globalWords, err := parseCspellResult(*outputPath, *threshold) + if err != nil { + fmt.Println("Error:", err) + return + } + + if config.IgnoreWords == nil { + config.IgnoreWords = make([]string, 0, len(globalWords)) + } + for word := range globalWords { + config.IgnoreWords = append(config.IgnoreWords, word) + fmt.Println(config.IgnoreWords) + } + slices.Sort(config.IgnoreWords) + for _, word := range config.IgnoreWords { + globalWords[word] = true + } + if config.IgnoreWordsMap == nil { + config.IgnoreWordsMap = make(map[string][]string, len(wordsByFile)) + } + for filePath, words := range wordsByFile { + words = slices.DeleteFunc(words, func(word string) bool { + return globalWords[strings.ToLower(word)] + }) + if len(words) > 0 { + im, ok := config.IgnoreWordsMap[filePath] + if !ok || im == nil { + slices.Sort(words) + config.IgnoreWordsMap[filePath] = words + } else { + words = append(im, words...) + slices.Sort(words) + config.IgnoreWordsMap[filePath] = slices.Compact(words) + } + } + } + + if err := saveConfig(*configPath, config); err != nil { + fmt.Println("Error: output path is required") + os.Exit(1) + } +} diff --git a/hack/docker/gen/main.go b/hack/docker/gen/main.go index 7750270efc..ef56101481 100644 --- a/hack/docker/gen/main.go +++ b/hack/docker/gen/main.go @@ -86,8 +86,9 @@ COPY {{$files}} {{- end}} SHELL ["/bin/bash", "-o", "pipefail", "-c"] #skipcq: DOK-W1001, DOK-SC2046, DOK-SC2086, DOK-DL3008 -RUN {{RunMounts .RunMounts}}\ - echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ +RUN {{RunMounts .RunMounts}} \ + set -ex \ + && echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache \ && echo 'APT::Install-Recommends "false";' > /etc/apt/apt.conf.d/no-install-recommends \ && apt-get clean \ && apt-get update -y \ @@ -223,6 +224,9 @@ const ( organization = "vdaas" repository = "vald" defaultBinaryDir = "/usr/bin" + usrLocal = "/usr/local" + usrLocalBinaryDir = usrLocal + "/bin" + usrLocalLibDir = usrLocal + "/lib" defaultBuilderImage = "ghcr.io/vdaas/vald/vald-buildbase" defaultBuilderTag = "nightly" defaultLanguage = "en_US.UTF-8" @@ -230,7 +234,8 @@ const ( defaultRuntimeImage = "gcr.io/distroless/static" defaultRuntimeTag = "nonroot" defaultRuntimeUser = "nonroot:nonroot" - defaultBuildUser = "root:root" + rootUser = "root" + defaultBuildUser = rootUser + ":" + rootUser defaultBuildStageName = "builder" maintainerKey = "MAINTAINER" minimumArgumentLength = 2 @@ -274,28 +279,28 @@ var ( defaultEnvironments = map[string]string{ "DEBIAN_FRONTEND": "noninteractive", - "HOME": "/root", - "USER": "root", + "HOME": "/" + rootUser, + "USER": rootUser, "INITRD": "No", "LANG": defaultLanguage, "LANGUAGE": defaultLanguage, "LC_ALL": defaultLanguage, "ORG": organization, "TZ": "Etc/UTC", - "PATH": "${PATH}:/usr/local/bin", + "PATH": "${PATH}:" + usrLocalBinaryDir, "REPO": repository, } goDefaultEnvironments = map[string]string{ "GOROOT": "/opt/go", "GOPATH": "/go", "GO111MODULE": "on", - "PATH": "${PATH}:${GOROOT}/bin:${GOPATH}/bin:/usr/local/bin", + "PATH": "${PATH}:${GOROOT}/bin:${GOPATH}/bin:" + usrLocalBinaryDir, } rustDefaultEnvironments = map[string]string{ - "RUST_HOME": "/usr/loacl/lib/rust", + "RUST_HOME": usrLocalLibDir + "/rust", "RUSTUP_HOME": "${RUST_HOME}/rustup", "CARGO_HOME": "${RUST_HOME}/cargo", - "PATH": "${PATH}:${RUSTUP_HOME}/bin:${CARGO_HOME}/bin:/usr/local/bin", + "PATH": "${PATH}:${RUSTUP_HOME}/bin:${CARGO_HOME}/bin:" + usrLocalBinaryDir, } clangDefaultEnvironments = map[string]string{ "CC": "gcc", @@ -324,10 +329,10 @@ var ( "--mount=type=cache,target=/var/lib/apt,sharing=locked", "--mount=type=cache,target=/var/cache/apt,sharing=locked", } - goDefaultMounts = []string{ "--mount=type=cache,target=\"${GOPATH}/pkg\",id=\"go-build-${TARGETARCH}\"", "--mount=type=cache,target=\"${HOME}/.cache/go-build\",id=\"go-build-${TARGETARCH}\"", + "--mount=type=tmpfs,target=\"${GOPATH}/src\"", } clangBuildDeps = []string{ @@ -372,7 +377,6 @@ var ( "make kubelinter/install", "make reviewdog/install", "make tparse/install", - "make valdcli/install", "make yq/install", "make minikube/install", "make stern/install", @@ -597,7 +601,7 @@ func main() { "OPERATOR_SDK_VERSION": "latest", }, ExtraCopies: []string{ - "--from=operator /usr/local/bin/${APP_NAME} {{$.BinDir}}/${APP_NAME}", + "--from=operator " + usrLocalBinaryDir + "/${APP_NAME} {{$.BinDir}}/${APP_NAME}", }, ExtraImages: []string{ "quay.io/operator-framework/helm-operator:${OPERATOR_SDK_VERSION} AS operator", @@ -790,9 +794,9 @@ func main() { data.RootDir = "${HOME}" data.Environments["ROOTDIR"] = os.Args[1] } - if strings.Contains(data.BuildUser, "root") { - data.Environments["HOME"] = "/root" - data.Environments["USER"] = "root" + if strings.Contains(data.BuildUser, rootUser) { + data.Environments["HOME"] = "/" + rootUser + data.Environments["USER"] = rootUser } else { user := data.BuildUser if strings.Contains(user, ":") { diff --git a/internal/backoff/backoff_test.go b/internal/backoff/backoff_test.go index 0549983bbb..1a57a004b2 100644 --- a/internal/backoff/backoff_test.go +++ b/internal/backoff/backoff_test.go @@ -288,7 +288,7 @@ func Test_backoff_Do(t *testing.T) { }(), func() test { ctx := context.Background() - err := errors.New("erros is occurred") + err := errors.New("errors is occurred") f := func(context.Context) (any, bool, error) { return nil, false, err } @@ -317,7 +317,7 @@ func Test_backoff_Do(t *testing.T) { }(), func() test { ctx := context.Background() - err := errors.New("erros is occurred") + err := errors.New("errors is occurred") f := func(context.Context) (any, bool, error) { return str, true, err } @@ -346,7 +346,7 @@ func Test_backoff_Do(t *testing.T) { }(), func() test { ctx := context.Background() - err := errors.New("erros is occurred") + err := errors.New("errors is occurred") cnt := 0 f := func(context.Context) (any, bool, error) { cnt++ @@ -380,7 +380,7 @@ func Test_backoff_Do(t *testing.T) { }(), func() test { ctx := context.Background() - err := errors.New("erros is occurred") + err := errors.New("errors is occurred") cnt := 0 f := func(context.Context) (any, bool, error) { cnt++ @@ -413,7 +413,7 @@ func Test_backoff_Do(t *testing.T) { }(), func() test { ctx := context.Background() - err := errors.New("erros is occurred") + err := errors.New("errors is occurred") f := func(context.Context) (any, bool, error) { return str, true, err } @@ -442,7 +442,7 @@ func Test_backoff_Do(t *testing.T) { }(), func() test { ctx := context.Background() - err := errors.New("erros is occurred") + err := errors.New("errors is occurred") f := func(context.Context) (any, bool, error) { return str, true, err } @@ -470,7 +470,7 @@ func Test_backoff_Do(t *testing.T) { }(), func() test { ctx, cancel := context.WithCancel(context.Background()) - err := errors.New("erros is occurred") + err := errors.New("errors is occurred") f := func(context.Context) (any, bool, error) { cancel() return str, true, err @@ -499,7 +499,7 @@ func Test_backoff_Do(t *testing.T) { }(), func() test { ctx, cancel := context.WithCancel(context.Background()) - err := errors.New("erros is occurred") + err := errors.New("errors is occurred") cnt := 0 f := func(context.Context) (any, bool, error) { cnt++ @@ -532,7 +532,7 @@ func Test_backoff_Do(t *testing.T) { }(), func() test { ctx := context.Background() - err := errors.New("erros is occurred") + err := errors.New("errors is occurred") cnt := 0 f := func(context.Context) (any, bool, error) { cnt++ diff --git a/internal/cache/gache/option_test.go b/internal/cache/gache/option_test.go index 1e35584599..625e1229aa 100644 --- a/internal/cache/gache/option_test.go +++ b/internal/cache/gache/option_test.go @@ -60,7 +60,7 @@ func TestDefaultOptions(t *testing.T) { tests := []test{ { - name: "set succuess", + name: "set success", want: want{ want: &cache[any]{ gache: gache.New[any](), @@ -122,7 +122,7 @@ func TestWithGache(t *testing.T) { func() test { ga := gache.New[any]() return test{ - name: "set succuess when g is not nil", + name: "set success when g is not nil", args: args{ g: ga, }, @@ -135,7 +135,7 @@ func TestWithGache(t *testing.T) { }(), func() test { return test{ - name: "set succuess when g is nil", + name: "set success when g is nil", want: want{ want: new(T), }, @@ -195,7 +195,7 @@ func TestWithExpiredHook(t *testing.T) { func() test { fn := func(context.Context, string) {} return test{ - name: "set succuess when f is not nil", + name: "set success when f is not nil", args: args{ f: fn, }, @@ -214,7 +214,7 @@ func TestWithExpiredHook(t *testing.T) { }(), func() test { return test{ - name: "set succuess when fn is nil", + name: "set success when fn is nil", want: want{ want: new(T), }, @@ -272,7 +272,7 @@ func TestWithExpireDuration(t *testing.T) { tests := []test{ { - name: "set succuess when dur is 0", + name: "set success when dur is 0", args: args{ dur: 0, }, @@ -281,7 +281,7 @@ func TestWithExpireDuration(t *testing.T) { }, }, { - name: "set succuess when dur is not 0", + name: "set success when dur is not 0", args: args{ dur: 10, }, @@ -343,7 +343,7 @@ func TestWithExpireCheckDuration(t *testing.T) { tests := []test{ { - name: "set succuess when dur is 0", + name: "set success when dur is 0", args: args{ dur: 0, }, @@ -352,7 +352,7 @@ func TestWithExpireCheckDuration(t *testing.T) { }, }, { - name: "set succuess when dur is not 0", + name: "set success when dur is not 0", args: args{ dur: 10, }, diff --git a/internal/cache/option.go b/internal/cache/option.go index ebedb19099..ef5a7583ae 100644 --- a/internal/cache/option.go +++ b/internal/cache/option.go @@ -55,7 +55,7 @@ func WithType[V any](mo string) Option[V] { } } -// WithExpireDuration returns Option after set expireDur when dur is cprrect param. +// WithExpireDuration returns Option after set expireDur when dur is correct param. func WithExpireDuration[V any](dur string) Option[V] { return func(c *cache[V]) { if len(dur) == 0 { @@ -69,7 +69,7 @@ func WithExpireDuration[V any](dur string) Option[V] { } } -// WithExpireCheckDuration returns Option after set expireCheckDur when dur is cprrect param. +// WithExpireCheckDuration returns Option after set expireCheckDur when dur is correct param. func WithExpireCheckDuration[V any](dur string) Option[V] { return func(c *cache[V]) { if len(dur) == 0 { diff --git a/internal/circuitbreaker/breaker.go b/internal/circuitbreaker/breaker.go index 29c499c000..81f3a455ef 100644 --- a/internal/circuitbreaker/breaker.go +++ b/internal/circuitbreaker/breaker.go @@ -35,7 +35,7 @@ type breaker struct { minSamples int64 openTimeout time.Duration openExp int64 // unix time - cloedRefreshTimeout time.Duration + closedRefreshTimeout time.Duration closedRefreshExp int64 // unix time } @@ -172,7 +172,7 @@ func (b *breaker) currentState() State { func (b *breaker) reset() { atomic.StoreInt32(&b.tripped, 0) atomic.StoreInt64(&b.openExp, 0) - atomic.StoreInt64(&b.closedRefreshExp, time.Now().Add(b.cloedRefreshTimeout).UnixNano()) + atomic.StoreInt64(&b.closedRefreshExp, time.Now().Add(b.closedRefreshTimeout).UnixNano()) b.count.reset() } diff --git a/internal/circuitbreaker/breaker_test.go b/internal/circuitbreaker/breaker_test.go index 234e6c2cb6..d0fd5ef680 100644 --- a/internal/circuitbreaker/breaker_test.go +++ b/internal/circuitbreaker/breaker_test.go @@ -35,7 +35,7 @@ func Test_breaker_isReady(t *testing.T) { minSamples int64 openTimeout time.Duration openExp int64 - cloedRefreshTimeout time.Duration + closedRefreshTimeout time.Duration closedRefreshExp int64 } type want struct { @@ -162,7 +162,7 @@ func Test_breaker_isReady(t *testing.T) { minSamples: test.fields.minSamples, openTimeout: test.fields.openTimeout, openExp: test.fields.openExp, - cloedRefreshTimeout: test.fields.cloedRefreshTimeout, + closedRefreshTimeout: test.fields.closedRefreshTimeout, closedRefreshExp: test.fields.closedRefreshExp, } @@ -186,7 +186,7 @@ func Test_breaker_success(t *testing.T) { minSamples int64 openTimeout time.Duration openExp int64 - cloedRefreshTimeout time.Duration + closedRefreshTimeout time.Duration closedRefreshExp int64 } type want struct{} @@ -281,7 +281,7 @@ func Test_breaker_success(t *testing.T) { minSamples: test.fields.minSamples, openTimeout: test.fields.openTimeout, openExp: test.fields.openExp, - cloedRefreshTimeout: test.fields.cloedRefreshTimeout, + closedRefreshTimeout: test.fields.closedRefreshTimeout, closedRefreshExp: test.fields.closedRefreshExp, } if test.afterFunc != nil { @@ -308,7 +308,7 @@ func Test_breaker_fail(t *testing.T) { minSamples int64 openTimeout time.Duration openExp int64 - cloedRefreshTimeout time.Duration + closedRefreshTimeout time.Duration closedRefreshExp int64 } type want struct{} @@ -409,7 +409,7 @@ func Test_breaker_fail(t *testing.T) { t.Errorf("state changed: %d", b.tripped) } if total := b.count.Total(); total == 0 { - t.Errorf("count reseted: %d", total) + t.Errorf("count resetted: %d", total) } }, } @@ -439,7 +439,7 @@ func Test_breaker_fail(t *testing.T) { minSamples: test.fields.minSamples, openTimeout: test.fields.openTimeout, openExp: test.fields.openExp, - cloedRefreshTimeout: test.fields.cloedRefreshTimeout, + closedRefreshTimeout: test.fields.closedRefreshTimeout, closedRefreshExp: test.fields.closedRefreshExp, } if test.afterFunc != nil { @@ -564,7 +564,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples int64 // openTimeout time.Duration // openExp int64 -// cloedRefreshTimeout time.Duration +// closedRefreshTimeout time.Duration // closedRefreshExp int64 // } // type want struct { @@ -613,7 +613,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples:0, // openTimeout:nil, // openExp:0, -// cloedRefreshTimeout:nil, +// closedRefreshTimeout:nil, // closedRefreshExp:0, // }, // want: want{}, @@ -647,7 +647,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples:0, // openTimeout:nil, // openExp:0, -// cloedRefreshTimeout:nil, +// closedRefreshTimeout:nil, // closedRefreshExp:0, // }, // want: want{}, @@ -689,7 +689,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples: test.fields.minSamples, // openTimeout: test.fields.openTimeout, // openExp: test.fields.openExp, -// cloedRefreshTimeout: test.fields.cloedRefreshTimeout, +// closedRefreshTimeout: test.fields.closedRefreshTimeout, // closedRefreshExp: test.fields.closedRefreshExp, // } // @@ -713,7 +713,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples int64 // openTimeout time.Duration // openExp int64 -// cloedRefreshTimeout time.Duration +// closedRefreshTimeout time.Duration // closedRefreshExp int64 // } // type want struct { @@ -749,7 +749,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples:0, // openTimeout:nil, // openExp:0, -// cloedRefreshTimeout:nil, +// closedRefreshTimeout:nil, // closedRefreshExp:0, // }, // want: want{}, @@ -779,7 +779,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples:0, // openTimeout:nil, // openExp:0, -// cloedRefreshTimeout:nil, +// closedRefreshTimeout:nil, // closedRefreshExp:0, // }, // want: want{}, @@ -821,7 +821,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples: test.fields.minSamples, // openTimeout: test.fields.openTimeout, // openExp: test.fields.openExp, -// cloedRefreshTimeout: test.fields.cloedRefreshTimeout, +// closedRefreshTimeout: test.fields.closedRefreshTimeout, // closedRefreshExp: test.fields.closedRefreshExp, // } // @@ -845,7 +845,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples int64 // openTimeout time.Duration // openExp int64 -// cloedRefreshTimeout time.Duration +// closedRefreshTimeout time.Duration // closedRefreshExp int64 // } // type want struct{} @@ -876,7 +876,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples:0, // openTimeout:nil, // openExp:0, -// cloedRefreshTimeout:nil, +// closedRefreshTimeout:nil, // closedRefreshExp:0, // }, // want: want{}, @@ -906,7 +906,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples:0, // openTimeout:nil, // openExp:0, -// cloedRefreshTimeout:nil, +// closedRefreshTimeout:nil, // closedRefreshExp:0, // }, // want: want{}, @@ -948,7 +948,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples: test.fields.minSamples, // openTimeout: test.fields.openTimeout, // openExp: test.fields.openExp, -// cloedRefreshTimeout: test.fields.cloedRefreshTimeout, +// closedRefreshTimeout: test.fields.closedRefreshTimeout, // closedRefreshExp: test.fields.closedRefreshExp, // } // @@ -972,7 +972,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples int64 // openTimeout time.Duration // openExp int64 -// cloedRefreshTimeout time.Duration +// closedRefreshTimeout time.Duration // closedRefreshExp int64 // } // type want struct{} @@ -1003,7 +1003,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples:0, // openTimeout:nil, // openExp:0, -// cloedRefreshTimeout:nil, +// closedRefreshTimeout:nil, // closedRefreshExp:0, // }, // want: want{}, @@ -1033,7 +1033,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples:0, // openTimeout:nil, // openExp:0, -// cloedRefreshTimeout:nil, +// closedRefreshTimeout:nil, // closedRefreshExp:0, // }, // want: want{}, @@ -1075,7 +1075,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples: test.fields.minSamples, // openTimeout: test.fields.openTimeout, // openExp: test.fields.openExp, -// cloedRefreshTimeout: test.fields.cloedRefreshTimeout, +// closedRefreshTimeout: test.fields.closedRefreshTimeout, // closedRefreshExp: test.fields.closedRefreshExp, // } // @@ -1099,7 +1099,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples int64 // openTimeout time.Duration // openExp int64 -// cloedRefreshTimeout time.Duration +// closedRefreshTimeout time.Duration // closedRefreshExp int64 // } // type want struct { @@ -1135,7 +1135,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples:0, // openTimeout:nil, // openExp:0, -// cloedRefreshTimeout:nil, +// closedRefreshTimeout:nil, // closedRefreshExp:0, // }, // want: want{}, @@ -1165,7 +1165,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples:0, // openTimeout:nil, // openExp:0, -// cloedRefreshTimeout:nil, +// closedRefreshTimeout:nil, // closedRefreshExp:0, // }, // want: want{}, @@ -1207,7 +1207,7 @@ func Test_breaker_fail(t *testing.T) { // minSamples: test.fields.minSamples, // openTimeout: test.fields.openTimeout, // openExp: test.fields.openExp, -// cloedRefreshTimeout: test.fields.cloedRefreshTimeout, +// closedRefreshTimeout: test.fields.closedRefreshTimeout, // closedRefreshExp: test.fields.closedRefreshExp, // } // diff --git a/internal/circuitbreaker/options.go b/internal/circuitbreaker/options.go index f48337a18e..9b02e8abe0 100644 --- a/internal/circuitbreaker/options.go +++ b/internal/circuitbreaker/options.go @@ -131,7 +131,7 @@ func WithClosedRefreshTimeout(timeout string) BreakerOption { if err != nil { return errors.NewErrInvalidOption("closedRefreshTimeout", timeout, err) } - b.cloedRefreshTimeout = d + b.closedRefreshTimeout = d return nil } } diff --git a/internal/client/v1/client/vald/vald.go b/internal/client/v1/client/vald/vald.go index 8b0578ce8b..586f9ceeb1 100644 --- a/internal/client/v1/client/vald/vald.go +++ b/internal/client/v1/client/vald/vald.go @@ -499,6 +499,28 @@ func (c *client) MultiUpdate( return res, nil } +func (c *client) UpdateTimestamp( + ctx context.Context, in *payload.Object_Timestamp, opts ...grpc.CallOption, +) (res *payload.Object_Location, err error) { + ctx, span := trace.StartSpan(grpc.WrapGRPCMethod(ctx, "internal/client/"+vald.UpdateTimestampRPCName), apiName+"/"+vald.UpdateTimestampRPCName) + defer func() { + if span != nil { + span.End() + } + }() + _, err = c.c.RoundRobin(ctx, func(ctx context.Context, + conn *grpc.ClientConn, + copts ...grpc.CallOption, + ) (any, error) { + res, err = vald.NewValdClient(conn).UpdateTimestamp(ctx, in, append(copts, opts...)...) + return nil, err + }) + if err != nil { + return nil, err + } + return res, nil +} + func (c *client) Upsert( ctx context.Context, in *payload.Upsert_Request, opts ...grpc.CallOption, ) (res *payload.Object_Location, err error) { @@ -1088,6 +1110,18 @@ func (c *singleClient) Update( return c.vc.Update(ctx, in, opts...) } +func (c *singleClient) UpdateTimestamp( + ctx context.Context, in *payload.Object_Timestamp, opts ...grpc.CallOption, +) (res *payload.Object_Location, err error) { + ctx, span := trace.StartSpan(grpc.WrapGRPCMethod(ctx, "internal/singleClient/"+vald.UpdateTimestampRPCName), apiName+"/"+vald.UpdateTimestampRPCName) + defer func() { + if span != nil { + span.End() + } + }() + return c.vc.UpdateTimestamp(ctx, in, opts...) +} + func (c *singleClient) StreamUpdate( ctx context.Context, opts ...grpc.CallOption, ) (res vald.Update_StreamUpdateClient, err error) { diff --git a/internal/compress/gob_test.go b/internal/compress/gob_test.go index 68545c880f..ef38462c70 100644 --- a/internal/compress/gob_test.go +++ b/internal/compress/gob_test.go @@ -391,7 +391,7 @@ func Test_gobCompressor_Reader(t *testing.T) { src io.ReadCloser } type fields struct { - transcodr gob.Transcoder + transcoder gob.Transcoder } type want struct { want io.ReadCloser @@ -425,7 +425,7 @@ func Test_gobCompressor_Reader(t *testing.T) { src: rc, }, fields: fields{ - transcodr: &gob.MockTranscoder{ + transcoder: &gob.MockTranscoder{ NewDecoderFunc: func(r io.Reader) gob.Decoder { return dec }, @@ -457,7 +457,7 @@ func Test_gobCompressor_Reader(t *testing.T) { checkFunc = defaultCheckFunc } g := &gobCompressor{ - transcoder: test.fields.transcodr, + transcoder: test.fields.transcoder, } got, err := g.Reader(test.args.src) diff --git a/internal/compress/lz4_test.go b/internal/compress/lz4_test.go index a54240d66a..989cf1c240 100644 --- a/internal/compress/lz4_test.go +++ b/internal/compress/lz4_test.go @@ -476,14 +476,14 @@ func Test_lz4Compressor_DecompressVector(t *testing.T) { }, }, { - name: "returns (nil, error) when decompresse fails", + name: "returns (nil, error) when decompress fails", args: args{ bs: []byte("vdaas/vald"), }, fields: fields{ gobc: &MockCompressor{ DecompressVectorFunc: func(bytes []byte) (vector []float32, err error) { - return nil, errors.New("decompresse err") + return nil, errors.New("decompress err") }, }, compressionLevel: 0, @@ -497,7 +497,7 @@ func Test_lz4Compressor_DecompressVector(t *testing.T) { }, want: want{ want: nil, - err: errors.New("decompresse err"), + err: errors.New("decompress err"), }, }, } @@ -653,7 +653,7 @@ func Test_lz4Compressor_Writer(t *testing.T) { w = new(lz4.MockWriter) ) return test{ - name: "returns (io.WriteCloser, nil) when no erro occurs", + name: "returns (io.WriteCloser, nil) when no error occurs", args: args{ dst: dst, }, diff --git a/internal/config/cassandra_test.go b/internal/config/cassandra_test.go index cfe1967498..8ffad55132 100644 --- a/internal/config/cassandra_test.go +++ b/internal/config/cassandra_test.go @@ -283,7 +283,7 @@ func TestCassandra_Bind(t *testing.T) { key := "CASSANDRA_BIND_PASSWORD" val := "cassandra_password" return test{ - name: "return Cassandra struct when Password is set via the envirionment value", + name: "return Cassandra struct when Password is set via the environment value", fields: fields{ Password: "_" + key + "_", }, diff --git a/internal/config/log.go b/internal/config/log.go index 4f8ca0c602..908e89c59c 100644 --- a/internal/config/log.go +++ b/internal/config/log.go @@ -24,7 +24,7 @@ type Logging struct { Format string `json:"format" yaml:"format"` } -// Bind returns Logging object whose every value is field value or envirionment value. +// Bind returns Logging object whose every value is field value or environment value. func (l *Logging) Bind() *Logging { l.Logger = GetActualValue(l.Logger) l.Level = GetActualValue(l.Level) diff --git a/internal/core/algorithm/ngt/ngt_test.go b/internal/core/algorithm/ngt/ngt_test.go index 82cffb9464..801ff7f88c 100644 --- a/internal/core/algorithm/ngt/ngt_test.go +++ b/internal/core/algorithm/ngt/ngt_test.go @@ -103,7 +103,7 @@ func TestNew(t *testing.T) { beforeFunc func(args) afterFunc func(*testing.T, NGT) error } - defaultComprators := append(ngtComparator, comparator.CompareField("idxPath", comparator.Comparer(func(s1, s2 string) bool { + defaultComparators := append(ngtComparator, comparator.CompareField("idxPath", comparator.Comparer(func(s1, s2 string) bool { return s1 == s2 }))) defaultCheckFunc := func(w want, got NGT, err error, comparators ...comparator.Option) error { @@ -234,7 +234,7 @@ func TestNew(t *testing.T) { } comparators := test.comparators if test.comparators == nil || len(test.comparators) == 0 { - comparators = defaultComprators + comparators = defaultComparators } got, err := New(test.args.opts...) @@ -692,7 +692,7 @@ func Test_gen(t *testing.T) { beforeFunc func(*testing.T, args) afterFunc func(*testing.T, NGT) error } - defaultComprators := append(ngtComparator, comparator.CompareField("idxPath", comparator.Comparer(func(s1, s2 string) bool { + defaultComparators := append(ngtComparator, comparator.CompareField("idxPath", comparator.Comparer(func(s1, s2 string) bool { return s1 == s2 }))) defaultCheckFunc := func(_ context.Context, w want, got NGT, err error, comparators ...comparator.Option) error { @@ -839,7 +839,7 @@ func Test_gen(t *testing.T) { } comparators := test.comparators if test.comparators == nil || len(test.comparators) == 0 { - comparators = defaultComprators + comparators = defaultComparators } got, err := gen(test.args.isLoad, test.args.opts...) @@ -1049,7 +1049,7 @@ func Test_ngt_loadOptions(t *testing.T) { }, }, { - name: "load option failed with Ignoreable error", + name: "load option failed with Ignorable error", args: args{ opts: []Option{ func(n *ngt) error { @@ -1107,7 +1107,7 @@ func Test_ngt_loadOptions(t *testing.T) { func Test_ngt_create(t *testing.T) { // This test is skipped because it requires ngt.prop to be set probably. // We cannot initialize ngt.prop since it is C dependencies. - // This function is called by New(), and the ngt.prop is destoried in New(), so we cannot test this function individually. + // This function is called by New(), and the ngt.prop is destroyed in New(), so we cannot test this function individually. t.SkipNow() } @@ -1476,7 +1476,7 @@ func Test_ngt_Search(t *testing.T) { }, }, { - name: "resturn vector id after the nearby vector inserted (uint8)", + name: "return vector id after the nearby vector inserted (uint8)", args: args{ ctx: context.Background(), vec: []float32{1, 2, 3, 4, 5, 6, 7, 8, 9}, @@ -1653,7 +1653,7 @@ func Test_ngt_Search(t *testing.T) { }, }, { - name: "resturn vector id after the nearby vector inserted (float)", + name: "return vector id after the nearby vector inserted (float)", args: args{ ctx: context.Background(), vec: []float32{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.91}, diff --git a/internal/db/rdb/mysql/dbr/dbr.go b/internal/db/rdb/mysql/dbr/dbr.go index e123403154..00702c9d6b 100644 --- a/internal/db/rdb/mysql/dbr/dbr.go +++ b/internal/db/rdb/mysql/dbr/dbr.go @@ -18,7 +18,7 @@ package dbr import dbr "github.com/gocraft/dbr/v2" -// DBR repreesnts the interface to create connection to MySQL. +// DBR represents the interface to create connection to MySQL. type DBR interface { Open(driver, dsn string, log EventReceiver) (Connection, error) Eq(col string, val any) Builder diff --git a/internal/db/rdb/mysql/dbr/insert.go b/internal/db/rdb/mysql/dbr/insert.go index 8d96e916c8..d15a9865fa 100644 --- a/internal/db/rdb/mysql/dbr/insert.go +++ b/internal/db/rdb/mysql/dbr/insert.go @@ -34,13 +34,13 @@ type insertStmt struct { *dbr.InsertStmt } -// Columns set colums to the insertStmt. +// Columns set column to the insertStmt. func (stmt *insertStmt) Columns(column ...string) InsertStmt { stmt.InsertStmt = stmt.InsertStmt.Columns(column...) return stmt } -// ExecContext execure inserting to the database. +// ExecContext execute inserting to the database. func (stmt *insertStmt) ExecContext(ctx context.Context) (sql.Result, error) { return stmt.InsertStmt.ExecContext(ctx) } diff --git a/internal/db/rdb/mysql/dbr/session.go b/internal/db/rdb/mysql/dbr/session.go index c1d8f60918..f6700947c1 100644 --- a/internal/db/rdb/mysql/dbr/session.go +++ b/internal/db/rdb/mysql/dbr/session.go @@ -39,7 +39,7 @@ func NewSession(conn Connection, event EventReceiver) Session { return conn.NewSession(event) } -// SeleSelect creates and returns the SelectStmt. +// Select creates and returns the SelectStmt. func (sess *session) Select(column ...string) SelectStmt { return &selectStmt{ sess.Session.Select(column...), @@ -56,7 +56,7 @@ func (sess *session) Begin() (Tx, error) { // Close closes the database and prevents new queries from starting. // Close then waits for all queries that have started processing on the server to finish. -// Close returns the errro if something goes worng during close. +// Close returns the error if something goes wrong during close. func (sess *session) Close() error { return sess.Session.Close() } diff --git a/internal/db/rdb/mysql/dbr/tx.go b/internal/db/rdb/mysql/dbr/tx.go index ce5dc2d02d..3713766f34 100644 --- a/internal/db/rdb/mysql/dbr/tx.go +++ b/internal/db/rdb/mysql/dbr/tx.go @@ -43,7 +43,7 @@ func (t *tx) Rollback() error { return t.Tx.Rollback() } -// RollbackUnlessCommitted rollsback the transaction unless it has already been committed or rolled back. +// RollbackUnlessCommitted rollbacks the transaction unless it has already been committed or rolled back. func (t *tx) RollbackUnlessCommitted() { t.Tx.RollbackUnlessCommitted() } diff --git a/internal/db/rdb/mysql/mysql_test.go b/internal/db/rdb/mysql/mysql_test.go index c741df72cd..4523b818af 100644 --- a/internal/db/rdb/mysql/mysql_test.go +++ b/internal/db/rdb/mysql/mysql_test.go @@ -1818,7 +1818,7 @@ func Test_mySQLClient_SetVector(t *testing.T) { } tx.InsertIntoFunc = func(table string) dbr.InsertStmt { s := new(dbr.MockInsert) - s.ColumnsFunc = func(colum ...string) dbr.InsertStmt { + s.ColumnsFunc = func(columns ...string) dbr.InsertStmt { return s } s.ExecContextFunc = func(ctx context.Context) (sql.Result, error) { @@ -1916,7 +1916,7 @@ func Test_mySQLClient_SetVector(t *testing.T) { } tx.InsertIntoFunc = func(table string) dbr.InsertStmt { s := new(dbr.MockInsert) - s.ColumnsFunc = func(colum ...string) dbr.InsertStmt { + s.ColumnsFunc = func(columns ...string) dbr.InsertStmt { return s } s.ExecContextFunc = func(ctx context.Context) (sql.Result, error) { @@ -2013,7 +2013,7 @@ func Test_mySQLClient_SetVector(t *testing.T) { } tx.InsertIntoFunc = func(table string) dbr.InsertStmt { s := new(dbr.MockInsert) - s.ColumnsFunc = func(colum ...string) dbr.InsertStmt { + s.ColumnsFunc = func(columns ...string) dbr.InsertStmt { return s } s.ExecContextFunc = func(ctx context.Context) (sql.Result, error) { @@ -2512,7 +2512,7 @@ func Test_mySQLClient_SetVectors(t *testing.T) { } tx.InsertIntoFunc = func(table string) dbr.InsertStmt { s := new(dbr.MockInsert) - s.ColumnsFunc = func(colum ...string) dbr.InsertStmt { + s.ColumnsFunc = func(columns ...string) dbr.InsertStmt { return s } s.ExecContextFunc = func(ctx context.Context) (sql.Result, error) { @@ -2612,7 +2612,7 @@ func Test_mySQLClient_SetVectors(t *testing.T) { } tx.InsertIntoFunc = func(table string) dbr.InsertStmt { s := new(dbr.MockInsert) - s.ColumnsFunc = func(colum ...string) dbr.InsertStmt { + s.ColumnsFunc = func(columns ...string) dbr.InsertStmt { return s } s.ExecContextFunc = func(ctx context.Context) (sql.Result, error) { @@ -2711,7 +2711,7 @@ func Test_mySQLClient_SetVectors(t *testing.T) { } tx.InsertIntoFunc = func(table string) dbr.InsertStmt { s := new(dbr.MockInsert) - s.ColumnsFunc = func(colum ...string) dbr.InsertStmt { + s.ColumnsFunc = func(columns ...string) dbr.InsertStmt { return s } s.ExecContextFunc = func(ctx context.Context) (sql.Result, error) { @@ -3022,7 +3022,7 @@ func Test_mySQLClient_DeleteVector(t *testing.T) { func() test { err := errors.ErrMySQLTransactionNotCreated return test{ - name: "return error when transacton is nil", + name: "return error when transaction is nil", args: args{ ctx: context.Background(), uuid: "vald-01", @@ -3217,9 +3217,9 @@ func Test_mySQLClient_DeleteVector(t *testing.T) { } }(), func() test { - err := errors.New("podIPTableNmae error") + err := errors.New("podIPTableName error") return test{ - name: "return error when DeleteFromFunc(podIPTableNmae) returns error", + name: "return error when DeleteFromFunc(podIPTableName) returns error", args: args{ ctx: context.Background(), uuid: "vald-01", @@ -3813,7 +3813,7 @@ func Test_mySQLClient_SetIPs(t *testing.T) { RollbackUnlessCommittedFunc: func() {}, InsertIntoFunc: func(table string) dbr.InsertStmt { s := new(dbr.MockInsert) - s.ColumnsFunc = func(colum ...string) dbr.InsertStmt { + s.ColumnsFunc = func(columns ...string) dbr.InsertStmt { return s } s.ExecContextFunc = func(ctx context.Context) (sql.Result, error) { @@ -3885,7 +3885,7 @@ func Test_mySQLClient_SetIPs(t *testing.T) { RollbackUnlessCommittedFunc: func() {}, InsertIntoFunc: func(table string) dbr.InsertStmt { s := new(dbr.MockInsert) - s.ColumnsFunc = func(colum ...string) dbr.InsertStmt { + s.ColumnsFunc = func(columns ...string) dbr.InsertStmt { return s } s.ExecContextFunc = func(ctx context.Context) (sql.Result, error) { diff --git a/internal/db/rdb/mysql/option.go b/internal/db/rdb/mysql/option.go index 7eac41b6d5..4a4c8b3194 100644 --- a/internal/db/rdb/mysql/option.go +++ b/internal/db/rdb/mysql/option.go @@ -182,7 +182,7 @@ func WithConnectionLifeTimeLimit(dur string) Option { } // WithMaxIdleConns returns the option to set the maxIdleConns. -// If conns is negative numner, no idle connections are retained. +// If conns is negative number, no idle connections are retained. // ref: https://golang.org/src/database/sql/sql.go?s=24983:25019#L879 func WithMaxIdleConns(conns int) Option { return func(m *mySQLClient) error { @@ -194,7 +194,7 @@ func WithMaxIdleConns(conns int) Option { } // WithMaxOpenConns returns the option to set the maxOpenConns. -// If conns is negative numner, no limit on the number of open connections. +// If conns is negative number, no limit on the number of open connections. // ref: https://golang.org/src/database/sql/sql.go?s=24983:25019#L923 func WithMaxOpenConns(conns int) Option { return func(m *mySQLClient) error { diff --git a/internal/db/storage/blob/cloudstorage/option.go b/internal/db/storage/blob/cloudstorage/option.go index 28ccb2a056..89561867e7 100644 --- a/internal/db/storage/blob/cloudstorage/option.go +++ b/internal/db/storage/blob/cloudstorage/option.go @@ -39,7 +39,7 @@ func WithURL(str string) Option { } } -// WithURLOpener returns Option that sets c.urlOpner. +// WithURLOpener returns Option that sets c.urlOpener. func WithURLOpener(uo *gcsblob.URLOpener) Option { return func(c *client) error { if uo != nil { diff --git a/internal/db/storage/blob/s3/reader/option.go b/internal/db/storage/blob/s3/reader/option.go index d71350d227..8a71e59fa2 100644 --- a/internal/db/storage/blob/s3/reader/option.go +++ b/internal/db/storage/blob/s3/reader/option.go @@ -60,7 +60,7 @@ func WithBucket(bucket string) Option { } } -// WithMaxChunkSize retunrs the option to set the maxChunkSize. +// WithMaxChunkSize returns the option to set the maxChunkSize. func WithMaxChunkSize(size int64) Option { return func(r *reader) { r.maxChunkSize = size diff --git a/internal/db/storage/blob/s3/s3_test.go b/internal/db/storage/blob/s3/s3_test.go index 3b4532c69b..04e6023472 100644 --- a/internal/db/storage/blob/s3/s3_test.go +++ b/internal/db/storage/blob/s3/s3_test.go @@ -389,7 +389,7 @@ func Test_client_Close(t *testing.T) { } tests := []test{ { - name: "retursn nil", + name: "returns nil", want: want{ err: nil, }, diff --git a/internal/db/storage/blob/s3/session/session_test.go b/internal/db/storage/blob/s3/session/session_test.go index ba4eb8c8f8..50389e4f04 100644 --- a/internal/db/storage/blob/s3/session/session_test.go +++ b/internal/db/storage/blob/s3/session/session_test.go @@ -503,7 +503,7 @@ func Test_sess_Session(t *testing.T) { }, }, { - name: "set EnableParamValdiation success", + name: "set EnableParamValidation success", fields: fields{ enableParamValidation: true, }, @@ -532,7 +532,7 @@ func Test_sess_Session(t *testing.T) { }, }, { - name: "set Enable100Conitnue success", + name: "set Enable100Continue success", fields: fields{ enable100Continue: true, }, diff --git a/internal/errors/agent.go b/internal/errors/agent.go index da16986ade..a25d13d043 100644 --- a/internal/errors/agent.go +++ b/internal/errors/agent.go @@ -115,4 +115,9 @@ var ( // ErrWriteOperationToReadReplica represents an error that when a write operation is made to read replica. ErrWriteOperationToReadReplica = New("write operation to read replica is not possible") + + // ErrInvalidTimestamp represents a function to generate an error that the timestamp is invalid. + ErrInvalidTimestamp = func(ts int64) error { + return Errorf("invalid timestamp detected", ts) + } ) diff --git a/internal/errors/corrector.go b/internal/errors/corrector.go index 5fbc08f44b..89f3434842 100644 --- a/internal/errors/corrector.go +++ b/internal/errors/corrector.go @@ -37,7 +37,7 @@ var ErrFailedToReceiveVectorFromStream = New("failed to receive vector from stre // ErrFailedToCheckConsistency represents an error that failed to check consistency process while index correction process. var ErrFailedToCheckConsistency = func(err error) error { - return Wrap(err, "failed to check consistency while index correctioin process") + return Wrap(err, "failed to check consistency while index correction process") } // ErrStreamListObjectStreamFinishedUnexpectedly represents an error that StreamListObject finished not because of io.EOF. diff --git a/internal/errors/grpc.go b/internal/errors/grpc.go index 4df3243912..9a39aae5db 100644 --- a/internal/errors/grpc.go +++ b/internal/errors/grpc.go @@ -63,7 +63,7 @@ var ( // ErrGRPCUnexpectedStatusError represents an error that the gRPC status code is undefined. ErrGRPCUnexpectedStatusError = func(code string, err error) error { - return Wrapf(err, "unexcepted error detected: code %s", code) + return Wrapf(err, "unexpected error detected: code %s", code) } // ErrInvalidProtoMessageType represents an error that the gRPC protocol buffers message type is invalid. diff --git a/internal/errors/net.go b/internal/errors/net.go index d21de4845a..1a64fa9cf6 100644 --- a/internal/errors/net.go +++ b/internal/errors/net.go @@ -37,7 +37,7 @@ var ( return Errorf("no port available for Host: %s\tbetween %d ~ %d", host, start, end) } - // ErrLookupIPAddrNotFound represents a function to generate an error that the host's ip address could not discovererd from DNS. + // ErrLookupIPAddrNotFound represents a function to generate an error that the host's ip address could not discovered from DNS. ErrLookupIPAddrNotFound = func(host string) error { return Errorf("failed to lookup ip addrs for host: %s", host) } diff --git a/internal/errors/option_test.go b/internal/errors/option_test.go index 8fba808dde..f5c904bbdc 100644 --- a/internal/errors/option_test.go +++ b/internal/errors/option_test.go @@ -50,7 +50,7 @@ func TestNewErrInvalidOption(t *testing.T) { name := "WithPort" val := 9000 return test{ - name: "return ErrInvalidOpton when name and val have a value and errs is empty.", + name: "return ErrInvalidOption when name and val have a value and errs is empty.", args: args{ name: name, val: val, @@ -70,7 +70,7 @@ func TestNewErrInvalidOption(t *testing.T) { } e := errs[0] return test{ - name: "return ErrInvalidOpton when all of parameter has value.", + name: "return ErrInvalidOption when all of parameter has value.", args: args{ name: name, val: val, @@ -93,7 +93,7 @@ func TestNewErrInvalidOption(t *testing.T) { } e := errs[1] return test{ - name: "return ErrInvalidOpton when all of parameter has value and errs has nil as value.", + name: "return ErrInvalidOption when all of parameter has value and errs has nil as value.", args: args{ name: name, val: val, @@ -115,7 +115,7 @@ func TestNewErrInvalidOption(t *testing.T) { } e := Wrap(errs[1], errs[0].Error()) return test{ - name: "return ErrInvalidOpton when name is nil and val and errs have values.", + name: "return ErrInvalidOption when name is nil and val and errs have values.", args: args{ val: val, errs: errs, @@ -136,7 +136,7 @@ func TestNewErrInvalidOption(t *testing.T) { } e := Wrap(errs[1], errs[0].Error()) return test{ - name: "return ErrInvalidOpton when val is nil and name and errs have values.", + name: "return ErrInvalidOption when val is nil and name and errs have values.", args: args{ name: name, errs: errs, diff --git a/internal/errors/redis.go b/internal/errors/redis.go index c27b47af56..99fd542132 100644 --- a/internal/errors/redis.go +++ b/internal/errors/redis.go @@ -21,7 +21,7 @@ var ( // ErrRedisInvalidKVVKPrefix represents a function to generate an error that kv index and vk prefix are invalid. ErrRedisInvalidKVVKPrefix = func(kv, vk string) error { - return Errorf("kv index and vk prefix must be defferent.\t(kv: %s,\tvk: %s)", kv, vk) + return Errorf("kv index and vk prefix must be different.\t(kv: %s,\tvk: %s)", kv, vk) } // ErrRedisNotFoundIdentity generates an RedisNotFoundIdentityError error. diff --git a/internal/errors/redis_test.go b/internal/errors/redis_test.go index c399adf6e7..8355f9fba3 100644 --- a/internal/errors/redis_test.go +++ b/internal/errors/redis_test.go @@ -24,7 +24,7 @@ import ( "github.com/vdaas/vald/internal/test/goleak" ) -func TestErrRedisInvalidKVVKPrefic(t *testing.T) { +func TestErrRedisInvalidKVVKPrefix(t *testing.T) { type fields struct { kv string vk string @@ -56,7 +56,7 @@ func TestErrRedisInvalidKVVKPrefic(t *testing.T) { vk: str, }, want: want{ - want: Errorf("kv index and vk prefix must be defferent.\t(kv: %s,\tvk: %s)", str, str), + want: Errorf("kv index and vk prefix must be different.\t(kv: %s,\tvk: %s)", str, str), }, } }(), @@ -67,7 +67,7 @@ func TestErrRedisInvalidKVVKPrefic(t *testing.T) { kv: str, }, want: want{ - want: Errorf("kv index and vk prefix must be defferent.\t(kv: %s,\tvk: %s)", str, ""), + want: Errorf("kv index and vk prefix must be different.\t(kv: %s,\tvk: %s)", str, ""), }, } }(), @@ -78,7 +78,7 @@ func TestErrRedisInvalidKVVKPrefic(t *testing.T) { vk: str, }, want: want{ - want: Errorf("kv index and vk prefix must be defferent.\t(kv: %s,\tvk: %s)", "", str), + want: Errorf("kv index and vk prefix must be different.\t(kv: %s,\tvk: %s)", "", str), }, } }(), @@ -87,7 +87,7 @@ func TestErrRedisInvalidKVVKPrefic(t *testing.T) { name: "return an ErrRedisInvalidKVVKPrefix error when kv and vk are empty", fields: fields{}, want: want{ - want: Errorf("kv index and vk prefix must be defferent.\t(kv: %s,\tvk: %s)", "", ""), + want: Errorf("kv index and vk prefix must be different.\t(kv: %s,\tvk: %s)", "", ""), }, } }(), @@ -167,7 +167,7 @@ func TestErrRedisNotFoundIdentity(t *testing.T) { } } -func TestErrRdisNotFound(t *testing.T) { +func TestErrRedisNotFound(t *testing.T) { type fields struct { key string } @@ -304,7 +304,7 @@ func TestErrRedisGetOperationFailed(t *testing.T) { tests := []test{ func() test { return test{ - name: "return a wraped error when key is not empty and err is not nil", + name: "return a wrapped error when key is not empty and err is not nil", fields: fields{ key: key, err: err, @@ -316,7 +316,7 @@ func TestErrRedisGetOperationFailed(t *testing.T) { }(), func() test { return test{ - name: "return a wraped error when key is not empty and err is nil", + name: "return a wrapped error when key is not empty and err is nil", fields: fields{ key: key, }, @@ -327,7 +327,7 @@ func TestErrRedisGetOperationFailed(t *testing.T) { }(), func() test { return test{ - name: "return a wraped error when key is empty and err is not nil", + name: "return a wrapped error when key is empty and err is not nil", fields: fields{ err: err, }, @@ -338,7 +338,7 @@ func TestErrRedisGetOperationFailed(t *testing.T) { }(), func() test { return test{ - name: "return a wraped error when key is empty and err is nil", + name: "return a wrapped error when key is empty and err is nil", fields: fields{}, want: want{ want: Wrap(nil, "Failed to fetch key ()"), @@ -396,7 +396,7 @@ func TestErrRedisSetOperationFailed(t *testing.T) { tests := []test{ func() test { return test{ - name: "return a wraped error when key is not empty and err is not nil", + name: "return a wrapped error when key is not empty and err is not nil", fields: fields{ key: key, err: err, @@ -408,7 +408,7 @@ func TestErrRedisSetOperationFailed(t *testing.T) { }(), func() test { return test{ - name: "return a wraped error when key is not empty and err is nil", + name: "return a wrapped error when key is not empty and err is nil", fields: fields{ key: key, }, @@ -419,7 +419,7 @@ func TestErrRedisSetOperationFailed(t *testing.T) { }(), func() test { return test{ - name: "return a wraped error when key is empty and err is not nil", + name: "return a wrapped error when key is empty and err is not nil", fields: fields{ err: err, }, @@ -430,7 +430,7 @@ func TestErrRedisSetOperationFailed(t *testing.T) { }(), func() test { return test{ - name: "return a wraped error when key is empty and err is nil", + name: "return a wrapped error when key is empty and err is nil", fields: fields{}, want: want{ want: Wrap(nil, "Failed to set key ()"), @@ -488,7 +488,7 @@ func TestErrRedisDeleteOperationFailed(t *testing.T) { tests := []test{ func() test { return test{ - name: "return a wraped error when key is not empty and err is not nil", + name: "return a wrapped error when key is not empty and err is not nil", fields: fields{ key: key, err: err, @@ -500,7 +500,7 @@ func TestErrRedisDeleteOperationFailed(t *testing.T) { }(), func() test { return test{ - name: "return a wraped error when key is not empty and err is nil", + name: "return a wrapped error when key is not empty and err is nil", fields: fields{ key: key, }, @@ -511,7 +511,7 @@ func TestErrRedisDeleteOperationFailed(t *testing.T) { }(), func() test { return test{ - name: "return a wraped error when key is empty and err is not nil", + name: "return a wrapped error when key is empty and err is not nil", fields: fields{ err: err, }, @@ -522,7 +522,7 @@ func TestErrRedisDeleteOperationFailed(t *testing.T) { }(), func() test { return test{ - name: "return a wraped error when key is empty and err is nil", + name: "return a wrapped error when key is empty and err is nil", fields: fields{}, want: want{ want: Wrap(nil, "Failed to delete key ()"), diff --git a/internal/errors/tls.go b/internal/errors/tls.go index 00357926c9..e714347ddf 100644 --- a/internal/errors/tls.go +++ b/internal/errors/tls.go @@ -20,10 +20,10 @@ package errors var ( // TLS. - // ErrTLSDisabled is error variable, it's replesents config error that tls is disabled by config. + // ErrTLSDisabled is error variable, it's represents config error that tls is disabled by config. ErrTLSDisabled = New("tls feature is disabled") - // ErrTLSCertOrKeyNotFound is error variable, it's replesents tls cert or key not found error. + // ErrTLSCertOrKeyNotFound is error variable, it's represents tls cert or key not found error. ErrTLSCertOrKeyNotFound = New("cert or key file path not found") ErrCertificationFailed = New("certification failed") diff --git a/internal/errors/vald.go b/internal/errors/vald.go index 949489a0b7..7ba363fcde 100644 --- a/internal/errors/vald.go +++ b/internal/errors/vald.go @@ -25,7 +25,7 @@ var ( // ErrSameVectorAlreadyExists represents an error that vald already has same features vector data. ErrSameVectorAlreadyExists = func(meta string, n, o []float32) error { - return Errorf("vald metadata:\t%s\talready exists reqested: %v, stored: %v", meta, n, o) + return Errorf("vald metadata:\t%s\talready exists requested: %v, stored: %v", meta, n, o) } // ErrMetaDataCannotFetch represents an error that vald metadata cannot fetch. diff --git a/internal/info/info.go b/internal/info/info.go index 6f5f31e0f9..223a507b07 100644 --- a/internal/info/info.go +++ b/internal/info/info.go @@ -280,7 +280,7 @@ func (d Detail) String() string { return "\n" + strings.Join(strs, "\n") } -// Get returns parased Detail object. +// Get returns parsed Detail object. func (i *info) Get() Detail { i.prepare() return i.getDetail() diff --git a/internal/log/option_test.go b/internal/log/option_test.go index 62bf9511fd..64a9ebecf3 100644 --- a/internal/log/option_test.go +++ b/internal/log/option_test.go @@ -148,7 +148,7 @@ func TestWithLoggerType(t *testing.T) { { name: "set nothing when str is invalid", args: args{ - str: "valdvaldinvalid", + str: "invalid", }, want: want{ obj: new(T), @@ -227,7 +227,7 @@ func TestWithLevel(t *testing.T) { { name: "set nothing when str is invalid", args: args{ - str: "valdvaldinvalid", + str: "invalid", }, want: want{ obj: new(T), @@ -312,7 +312,7 @@ func TestWithFormat(t *testing.T) { return test{ name: "set nothing when str is invalid", args: args{ - str: "valdvaldinvalid", + str: "invalid", }, want: want{ obj: new(T), diff --git a/internal/net/dialer_test.go b/internal/net/dialer_test.go index 3e366b1f22..22183ede9e 100644 --- a/internal/net/dialer_test.go +++ b/internal/net/dialer_test.go @@ -1163,7 +1163,7 @@ func Test_dialer_cachedDialer(t *testing.T) { // check the connection made on the same port _, p, _ := net.SplitHostPort(gotConn.RemoteAddr().String()) if p != strconv.Itoa(int(port)) { - return errors.Errorf("unexcepted port number, except: %d, got: %s", port, p) + return errors.Errorf("unexpected port number, except: %d, got: %s", port, p) } // read the output from the server and check if it is equals to the count diff --git a/internal/net/grpc/interceptor/client/metric/metric.go b/internal/net/grpc/interceptor/client/metric/metric.go index 7bcec5833f..2530fd06c8 100644 --- a/internal/net/grpc/interceptor/client/metric/metric.go +++ b/internal/net/grpc/interceptor/client/metric/metric.go @@ -40,7 +40,7 @@ const ( func ClientMetricInterceptors() (grpc.UnaryClientInterceptor, grpc.StreamClientInterceptor, error) { meter := metrics.GetMeter() - latencyHistgram, err := meter.Float64Histogram( + latencyHistogram, err := meter.Float64Histogram( latencyMetricsName, metrics.WithDescription("Client latency in milliseconds, by method"), metrics.WithUnit(metrics.Milliseconds), @@ -60,7 +60,7 @@ func ClientMetricInterceptors() (grpc.UnaryClientInterceptor, grpc.StreamClientI record := func(ctx context.Context, method string, err error, latency float64) { attrs := attributesFromError(method, err) - latencyHistgram.Record(ctx, latency, metrics.WithAttributes(attrs...)) + latencyHistogram.Record(ctx, latency, metrics.WithAttributes(attrs...)) completedRPCCnt.Add(ctx, 1, metrics.WithAttributes(attrs...)) } return func(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error { diff --git a/internal/net/grpc/interceptor/server/metric/metric.go b/internal/net/grpc/interceptor/server/metric/metric.go index 574386d483..d0bba7e075 100644 --- a/internal/net/grpc/interceptor/server/metric/metric.go +++ b/internal/net/grpc/interceptor/server/metric/metric.go @@ -36,7 +36,7 @@ const ( func MetricInterceptors() (grpc.UnaryServerInterceptor, grpc.StreamServerInterceptor, error) { meter := metrics.GetMeter() - latencyHistgram, err := meter.Float64Histogram( + latencyHistogram, err := meter.Float64Histogram( latencyMetricsName, metrics.WithDescription("Server latency in milliseconds, by method"), metrics.WithUnit(metrics.Milliseconds), @@ -56,7 +56,7 @@ func MetricInterceptors() (grpc.UnaryServerInterceptor, grpc.StreamServerInterce record := func(ctx context.Context, method string, err error, latency float64) { attrs := attributesFromError(method, err) - latencyHistgram.Record(ctx, latency, metrics.WithAttributes(attrs...)) + latencyHistogram.Record(ctx, latency, metrics.WithAttributes(attrs...)) completedRPCCnt.Add(ctx, 1, metrics.WithAttributes(attrs...)) } return func(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp any, err error) { diff --git a/internal/net/http/json/json_test.go b/internal/net/http/json/json_test.go index a0f3dbef24..d12189dcf9 100644 --- a/internal/net/http/json/json_test.go +++ b/internal/net/http/json/json_test.go @@ -377,7 +377,7 @@ func TestErrorHandler(t *testing.T) { } if got, want := w.Code, http.StatusInternalServerError; got != want { - return errors.Errorf("reso code not equals. want: %v, got: %v", http.StatusInternalServerError, got) + return errors.Errorf("response code not equals. want: %v, got: %v", http.StatusInternalServerError, got) } return nil }, @@ -666,7 +666,7 @@ func TestRequest(t *testing.T) { ctx context.Context method string url string - payloyd any + payload any data any } type want struct { @@ -694,7 +694,7 @@ func TestRequest(t *testing.T) { ctx: context.Background(), method: "@", url: "/", - payloyd: nil, + payload: nil, data: nil, }, want: want{ @@ -709,7 +709,7 @@ func TestRequest(t *testing.T) { ctx: context.Background(), method: "POST", url: "/", - payloyd: 1 + 3i, + payload: 1 + 3i, data: new(any), }, checkFunc: func(w want, err error) error { @@ -730,7 +730,7 @@ func TestRequest(t *testing.T) { ctx: context.Background(), method: "POST", url: "/", - payloyd: "1", + payload: "1", data: new(any), }, want: want{ @@ -753,7 +753,7 @@ func TestRequest(t *testing.T) { ctx: context.Background(), method: "POST", url: srv.URL, - payloyd: "1", + payload: "1", data: &got, }, want: want{ @@ -791,7 +791,7 @@ func TestRequest(t *testing.T) { checkFunc = defaultCheckFunc } - err := Request(test.args.ctx, test.args.method, test.args.url, test.args.payloyd, test.args.data) + err := Request(test.args.ctx, test.args.method, test.args.url, test.args.payload, test.args.data) if err := checkFunc(test.want, err); err != nil { tt.Errorf("error = %v", err) } diff --git a/internal/tls/tls.go b/internal/tls/tls.go index 64811db689..7b8869a2f4 100644 --- a/internal/tls/tls.go +++ b/internal/tls/tls.go @@ -49,7 +49,7 @@ var ( // NewTLSConfig returns a *tls.Config struct or error // This function read TLS configuration and initialize *tls.Config struct. // This function initialize TLS configuration, for example the CA certificate and key to start TLS server. -// Server and CA Certificate, and private key will read from a file from the file path definied in environment variable. +// Server and CA Certificate, and private key will read from a file from the file path defined in environment variable. func New(opts ...Option) (*Config, error) { c, err := newCredential(opts...) if err != nil { diff --git a/internal/worker/queue.go b/internal/worker/queue.go index 0ec5a7c68c..3abf9d89c0 100644 --- a/internal/worker/queue.go +++ b/internal/worker/queue.go @@ -64,8 +64,8 @@ func NewQueue(opts ...QueueOption) (Queue, error) { return q, nil } -// Start starts execute queueing if queue is not runnnig. -// If queue is already reunning, it returns error. +// Start starts execute queueing if queue is not running. +// If queue is already running, it returns error. // It returns the error channel that the queueing job return. func (q *queue) Start(ctx context.Context) (<-chan error, error) { if q.isRunning() { @@ -132,7 +132,7 @@ func (q *queue) Push(ctx context.Context, job JobFunc) error { } } -// Pop returns (JobFunc, nil) if the channnel, which will be used for queuing job, contains JobFunc. +// Pop returns (JobFunc, nil) if the channel, which will be used for queuing job, contains JobFunc. // It returns (nil ,error) if it failed to pop from the job queue. func (q *queue) Pop(ctx context.Context) (JobFunc, error) { tryCnt := int(q.Len()) + 1 // include the first try diff --git a/internal/worker/queue_option.go b/internal/worker/queue_option.go index 7b432e747a..a2be4b4c14 100644 --- a/internal/worker/queue_option.go +++ b/internal/worker/queue_option.go @@ -52,7 +52,7 @@ func WithQueueErrGroup(eg errgroup.Group) QueueOption { } // WithQueueCheckDuration returns the option to set the qcdur for queue. -// If dur is invalid string, it returns errror. +// If dur is invalid string, it returns error. func WithQueueCheckDuration(dur string) QueueOption { return func(q *queue) error { if len(dur) == 0 { diff --git a/pkg/agent/core/faiss/service/faiss.go b/pkg/agent/core/faiss/service/faiss.go index 4d301200a1..d7409e2730 100644 --- a/pkg/agent/core/faiss/service/faiss.go +++ b/pkg/agent/core/faiss/service/faiss.go @@ -916,7 +916,7 @@ func (f *faiss) saveIndex(ctx context.Context) error { // no cleanup invalid index eg, ectx := errgroup.New(ctx) - // we want to ensure the acutal kvs size between kvsdb and metadata, + // we want to ensure the actual kvs size between kvsdb and metadata, // so we create this counter to count the actual kvs size instead of using kvs.Len() var ( kvsLen uint64 diff --git a/pkg/agent/core/ngt/handler/grpc/object_test.go b/pkg/agent/core/ngt/handler/grpc/object_test.go index 39b5521bbb..6ab2f52a9d 100644 --- a/pkg/agent/core/ngt/handler/grpc/object_test.go +++ b/pkg/agent/core/ngt/handler/grpc/object_test.go @@ -1300,7 +1300,7 @@ func Test_server_StreamListObject(t *testing.T) { // Call the method under test err = s.StreamListObject(&payload.Object_List_Request{}, &stream) - // Check the errros are joined and its a gRPC error + // Check the errors are joined and its a gRPC error require.ErrorContains(t, err, "foo") require.ErrorContains(t, err, "bar") _, ok := status.FromError(err) diff --git a/pkg/agent/core/ngt/service/ngt.go b/pkg/agent/core/ngt/service/ngt.go index 095f0b6f0a..81d8a1a33d 100644 --- a/pkg/agent/core/ngt/service/ngt.go +++ b/pkg/agent/core/ngt/service/ngt.go @@ -531,7 +531,7 @@ func (n *ngt) load(ctx context.Context, path string, opts ...core.Option) (err e // backupBroken backup index at originPath into brokenDir. // The name of the directory will be timestamp(UnixNano). -// If it exeeds the limit, backupBroken removes the oldest backup directory. +// If it exceeds the limit, backupBroken removes the oldest backup directory. func (n *ngt) backupBroken(ctx context.Context) error { if n.historyLimit <= 0 { return nil @@ -1344,7 +1344,7 @@ func (n *ngt) CreateIndex(ctx context.Context, poolSize uint32) (err error) { } log.Infof("create index operation started, uncommitted indexes = %d", ic) log.Debug("create index delete phase started") - // vqProcessedCnt is a tempral counter to store the number of processed vqueue items. + // vqProcessedCnt is a temporary counter to store the number of processed vqueue items. // This will be added to nopvq after CreateIndex operation succeeds. var vqProcessedCnt uint64 n.vq.RangePopDelete(ctx, now, func(uuid string) bool { @@ -1570,7 +1570,7 @@ func (n *ngt) saveIndex(ctx context.Context) (err error) { beforeNopvq := n.nopvq.Load() defer n.gc() - // since defering here, atomic operations are guaranteed in this scope + // since deferring here, atomic operations are guaranteed in this scope defer n.saving.Store(false) log.Debug("cleanup invalid index started") @@ -1578,7 +1578,7 @@ func (n *ngt) saveIndex(ctx context.Context) (err error) { log.Debug("cleanup invalid index finished") eg, ectx := errgroup.New(ctx) - // we want to ensure the acutal kvs size between kvsdb and metadata, + // we want to ensure the actual kvs size between kvsdb and metadata, // so we create this counter to count the actual kvs size instead of using kvs.Len() var ( kvsLen uint64 diff --git a/pkg/agent/core/ngt/service/ngt_test.go b/pkg/agent/core/ngt/service/ngt_test.go index 71eb5d3b2e..4cc18bbebe 100644 --- a/pkg/agent/core/ngt/service/ngt_test.go +++ b/pkg/agent/core/ngt/service/ngt_test.go @@ -650,7 +650,7 @@ func Test_needsBackup(t *testing.T) { tmpDir := t.TempDir() validIndexDir := testdata.GetTestdataPath(testdata.ValidIndex) return test{ - name: "returns false when it's an initaial state", + name: "returns false when it's an initial state", args: args{ path: tmpDir, }, @@ -707,7 +707,7 @@ func Test_needsBackup(t *testing.T) { tmpDir := t.TempDir() validIndexDir := testdata.GetTestdataPath(testdata.ValidIndex) return test{ - name: "returns true when mets.IsInvalid is true", + name: "returns true when meta.IsInvalid is true", args: args{ path: tmpDir, }, @@ -738,7 +738,7 @@ func Test_needsBackup(t *testing.T) { tmpDir := t.TempDir() validIndexDir := testdata.GetTestdataPath(testdata.ValidIndex) return test{ - name: "returns true when mets.IsInvalid is true", + name: "returns true when meta.IsInvalid is true", args: args{ path: tmpDir, }, @@ -1370,7 +1370,7 @@ func Test_ngt_InsertUpsert(t *testing.T) { return } type args struct { - idxes []index + indices []index poolSize uint32 bulkSize int } @@ -1444,7 +1444,7 @@ func Test_ngt_InsertUpsert(t *testing.T) { return test{ name: fmt.Sprintf("insert & upsert %d random and 11 digits added to each vector element", count), args: args{ - idxes: createRandomData(count, &createRandomDataConfig{ + indices: createRandomData(count, &createRandomDataConfig{ additionaldigits: 11, }), poolSize: uint32(count / 10), @@ -1490,7 +1490,7 @@ func Test_ngt_InsertUpsert(t *testing.T) { if err != nil { tt.Errorf("failed to init ngt service, error = %v", err) } - for _, idx := range test.args.idxes { + for _, idx := range test.args.indices { err = n.Insert(idx.uuid, idx.vec) if err := checkFunc(test.want, err); err != nil { tt.Errorf("error = %v", err) @@ -1508,7 +1508,7 @@ func Test_ngt_InsertUpsert(t *testing.T) { idx := i eg.Go(safety.RecoverFunc(func() error { log.Warnf("started %d-1", idx) - for _, idx := range test.args.idxes[:len(test.args.idxes)/3] { + for _, idx := range test.args.indices[:len(test.args.indices)/3] { _ = n.Delete(idx.uuid) _ = n.Insert(idx.uuid, idx.vec) } @@ -1518,7 +1518,7 @@ func Test_ngt_InsertUpsert(t *testing.T) { eg.Go(safety.RecoverFunc(func() error { log.Warnf("started %d-2", idx) - for _, idx := range test.args.idxes[len(test.args.idxes)/3 : 2*len(test.args.idxes)/3] { + for _, idx := range test.args.indices[len(test.args.indices)/3 : 2*len(test.args.indices)/3] { _ = n.Delete(idx.uuid) _ = n.Insert(idx.uuid, idx.vec) } @@ -1528,7 +1528,7 @@ func Test_ngt_InsertUpsert(t *testing.T) { eg.Go(safety.RecoverFunc(func() error { log.Warnf("started %d-3", idx) - for _, idx := range test.args.idxes[2*len(test.args.idxes)/3:] { + for _, idx := range test.args.indices[2*len(test.args.indices)/3:] { _ = n.Delete(idx.uuid) _ = n.Insert(idx.uuid, idx.vec) } @@ -1569,9 +1569,9 @@ func Test_ngt_E2E(t *testing.T) { beforeFunc func(args) afterFunc func(args) } - multiUpsertRequestGenFunc := func(idxes []index, chunk int) (res []*payload.Upsert_MultiRequest) { + multiUpsertRequestGenFunc := func(indices []index, chunk int) (res []*payload.Upsert_MultiRequest) { reqs := make([]*payload.Upsert_Request, 0, chunk) - for i := 0; i < len(idxes); i++ { + for i := 0; i < len(indices); i++ { if len(reqs) == chunk-1 { res = append(res, &payload.Upsert_MultiRequest{ Requests: reqs, @@ -1580,8 +1580,8 @@ func Test_ngt_E2E(t *testing.T) { } else { reqs = append(reqs, &payload.Upsert_Request{ Vector: &payload.Object_Vector{ - Id: idxes[i].uuid, - Vector: idxes[i].vec, + Id: indices[i].uuid, + Vector: indices[i].vec, }, Config: &payload.Upsert_Config{ SkipStrictExistCheck: true, diff --git a/pkg/agent/internal/kvs/kvs_test.go b/pkg/agent/internal/kvs/kvs_test.go index c9dbd9db14..81fe8953ca 100644 --- a/pkg/agent/internal/kvs/kvs_test.go +++ b/pkg/agent/internal/kvs/kvs_test.go @@ -229,7 +229,7 @@ func Test_bidi_Get(t *testing.T) { ) return test{ - name: "return the value when there is a value for the key and l of fields is maximun value of uint64", + name: "return the value when there is a value for the key and l of fields is maximum value of uint64", args: args{ key: key, }, @@ -496,7 +496,7 @@ func Test_bidi_GetInverse(t *testing.T) { ) return test{ - name: "return key and timestamp and true when there is a key for the value and l of fields is maximun value of uint64", + name: "return key and timestamp and true when there is a key for the value and l of fields is maximum value of uint64", args: args{ val: val, }, @@ -770,7 +770,7 @@ func Test_bidi_Set(t *testing.T) { ) return test{ - name: "set success when the key is not empty string and val is not 0 and l of fields is maximun value of uint64", + name: "set success when the key is not empty string and val is not 0 and l of fields is maximum value of uint64", args: args{ key: key, val: val, @@ -806,7 +806,7 @@ func Test_bidi_Set(t *testing.T) { ) return test{ - name: "set success when the key is already set and the same key is set twie", + name: "set success when the key is already set and the same key is set twice", args: args{ key: key, val: val, @@ -1071,7 +1071,7 @@ func Test_bidi_Delete(t *testing.T) { ) return test{ - name: "return val and true when the delete successes and l of fields is maximun value of uint64", + name: "return val and true when the delete successes and l of fields is maximum value of uint64", args: args{ key: key, }, @@ -1353,7 +1353,7 @@ func Test_bidi_DeleteInverse(t *testing.T) { ) return test{ - name: "return key and true when the delete successes and l of fields is maximun value of uint64", + name: "return key and true when the delete successes and l of fields is maximum value of uint64", args: args{ val: val, }, @@ -1644,7 +1644,7 @@ func Test_bidi_Range(t *testing.T) { var mu sync.Mutex return test{ - name: "rage get successes when l of fields is maximun value of uint64", + name: "rage get successes when l of fields is maximum value of uint64", args: args{ f: func(s string, u uint32, t int64) bool { mu.Lock() @@ -1743,7 +1743,7 @@ func Test_bidi_Len(t *testing.T) { }, }, { - name: "return maximun value when l of field is maximun value of uint64", + name: "return maximum value when l of field is maximum value of uint64", fields: fields{ l: math.MaxUint64, }, diff --git a/pkg/gateway/lb/handler/grpc/handler.go b/pkg/gateway/lb/handler/grpc/handler.go index 205316e5c5..b91dffd05d 100644 --- a/pkg/gateway/lb/handler/grpc/handler.go +++ b/pkg/gateway/lb/handler/grpc/handler.go @@ -361,55 +361,17 @@ func (s *server) SearchByID( } return nil, err } - vec, err := s.getObject(ctx, uuid) + vec, err := s.GetObject(ctx, &payload.Object_VectorRequest{ + Id: &payload.Object_ID{ + Id: uuid, + }, + }) if err != nil { - var ( - attrs trace.Attributes - st *status.Status - msg string - ) - switch { - case errors.Is(err, errors.ErrInvalidUUID(uuid)): - err = status.WrapWithInvalidArgument( - vald.GetObjectRPCName+" API for "+vald.SearchByIDRPCName+" API invalid argument for uuid \""+uuid+"\" detected", - err, - reqInfo, - resInfo, - &errdetails.BadRequest{ - FieldViolations: []*errdetails.BadRequestFieldViolation{ - { - Field: "uuid", - Description: err.Error(), - }, - }, - }, - ) - attrs = trace.StatusCodeInvalidArgument(err.Error()) - case errors.Is(err, errors.ErrGRPCClientConnNotFound("*")): - err = status.WrapWithInternal(vald.GetObjectRPCName+" API for "+vald.SearchByIDRPCName+" API connection not found", err, reqInfo, resInfo) - attrs = trace.StatusCodeInternal(err.Error()) - case errors.Is(err, context.Canceled): - err = status.WrapWithCanceled(vald.GetObjectRPCName+" API for "+vald.SearchByIDRPCName+" API canceled", err, reqInfo, resInfo) - attrs = trace.StatusCodeCancelled(err.Error()) - case errors.Is(err, context.DeadlineExceeded): - err = status.WrapWithDeadlineExceeded(vald.GetObjectRPCName+" API for "+vald.SearchByIDRPCName+" API deadline exceeded", err, reqInfo, resInfo) - attrs = trace.StatusCodeDeadlineExceeded(err.Error()) - case errors.Is(err, errors.ErrObjectIDNotFound(uuid)), errors.Is(err, errors.ErrObjectNotFound(nil, uuid)): - err = nil - default: - st, msg, err = status.ParseError(err, codes.Unknown, vald.GetObjectRPCName+" API for "+vald.SearchByIDRPCName+" API uuid "+uuid+"'s request returned error", reqInfo, resInfo) - attrs = trace.FromGRPCStatus(st.Code(), msg) - if st == nil || st.Code() == codes.NotFound { - err = nil - } - } - if err != nil { - if span != nil { - span.RecordError(err) - span.SetAttributes(attrs...) - span.SetStatus(trace.StatusError, err.Error()) - } - return nil, err + st, msg, err := status.ParseError(err, codes.Unknown, vald.GetObjectRPCName+" API for "+vald.SearchByIDRPCName+" API uuid "+uuid+"'s request returned error", reqInfo, resInfo) + if span != nil && st != nil && st.Code() != codes.NotFound { + span.RecordError(err) + span.SetAttributes(trace.FromGRPCStatus(st.Code(), st.Message())...) + span.SetStatus(trace.StatusError, err.Error()) } // try search by using agent's SearchByID method this operation is emergency fallback, the search quality is not same as usual SearchByID operation. res, err = s.doSearch(ctx, req.GetConfig(), func(ctx context.Context, fcfg *payload.Search_Config, vc vald.Client, copts ...grpc.CallOption) (*payload.Search_Response, error) { @@ -851,55 +813,17 @@ func (s *server) LinearSearchByID( } return nil, err } - vec, err := s.getObject(ctx, uuid) + vec, err := s.GetObject(ctx, &payload.Object_VectorRequest{ + Id: &payload.Object_ID{ + Id: uuid, + }, + }) if err != nil { - var ( - attrs trace.Attributes - st *status.Status - msg string - ) - switch { - case errors.Is(err, errors.ErrInvalidUUID(uuid)): - err = status.WrapWithInvalidArgument( - vald.GetObjectRPCName+" API for "+vald.LinearSearchByIDRPCName+" API invalid argument for uuid \""+uuid+"\" detected", - err, - reqInfo, - resInfo, - &errdetails.BadRequest{ - FieldViolations: []*errdetails.BadRequestFieldViolation{ - { - Field: "uuid", - Description: err.Error(), - }, - }, - }, - ) - attrs = trace.StatusCodeInvalidArgument(err.Error()) - case errors.Is(err, errors.ErrGRPCClientConnNotFound("*")): - err = status.WrapWithInternal(vald.GetObjectRPCName+" API for "+vald.LinearSearchByIDRPCName+" API connection not found", err, reqInfo, resInfo) - attrs = trace.StatusCodeInternal(err.Error()) - case errors.Is(err, context.Canceled): - err = status.WrapWithCanceled(vald.GetObjectRPCName+" API for "+vald.LinearSearchByIDRPCName+" API canceled", err, reqInfo, resInfo) - attrs = trace.StatusCodeCancelled(err.Error()) - case errors.Is(err, context.DeadlineExceeded): - err = status.WrapWithDeadlineExceeded(vald.GetObjectRPCName+" API for "+vald.LinearSearchByIDRPCName+" API deadline exceeded", err, reqInfo, resInfo) - attrs = trace.StatusCodeDeadlineExceeded(err.Error()) - case errors.Is(err, errors.ErrObjectIDNotFound(uuid)), errors.Is(err, errors.ErrObjectNotFound(nil, uuid)): - err = nil - default: - st, msg, err = status.ParseError(err, codes.Unknown, vald.GetObjectRPCName+" API for "+vald.LinearSearchByIDRPCName+" API uuid "+uuid+"'s request returned error", reqInfo, resInfo) - attrs = trace.FromGRPCStatus(st.Code(), msg) - if st == nil || st.Code() == codes.NotFound { - err = nil - } - } - if err != nil { - if span != nil { - span.RecordError(err) - span.SetAttributes(attrs...) - span.SetStatus(trace.StatusError, err.Error()) - } - return nil, err + st, msg, err := status.ParseError(err, codes.Unknown, vald.GetObjectRPCName+" API for "+vald.LinearSearchByIDRPCName+" API uuid "+uuid+"'s request returned error", reqInfo, resInfo) + if span != nil && st != nil && st.Code() != codes.NotFound { + span.RecordError(err) + span.SetAttributes(trace.FromGRPCStatus(st.Code(), st.Message())...) + span.SetStatus(trace.StatusError, err.Error()) } // try search by using agent's LinearSearchByID method this operation is emergency fallback, the search quality is not same as usual LinearSearchByID operation. res, err = s.doSearch(ctx, req.GetConfig(), func(ctx context.Context, fcfg *payload.Search_Config, vc vald.Client, copts ...grpc.CallOption) (*payload.Search_Response, error) { @@ -1778,54 +1702,16 @@ func (s *server) Update( } if !req.GetConfig().GetSkipStrictExistCheck() { - vec, err := s.getObject(ctx, uuid) - if err != nil || vec == nil { - var ( - attrs trace.Attributes - st *status.Status - msg string - ) - switch { - case errors.Is(err, errors.ErrInvalidUUID(uuid)): - err = status.WrapWithInvalidArgument( - vald.GetObjectRPCName+" API for "+vald.UpdateRPCName+" API invalid argument for uuid \""+uuid+"\" detected", - err, - reqInfo, - resInfo, - &errdetails.BadRequest{ - FieldViolations: []*errdetails.BadRequestFieldViolation{ - { - Field: "uuid", - Description: err.Error(), - }, - }, - }, - ) - attrs = trace.StatusCodeInvalidArgument(err.Error()) - case errors.Is(err, errors.ErrGRPCClientConnNotFound("*")): - err = status.WrapWithInternal(vald.GetObjectRPCName+" API for "+vald.UpdateRPCName+" API connection not found", err, reqInfo, resInfo) - attrs = trace.StatusCodeInternal(err.Error()) - case errors.Is(err, context.Canceled): - err = status.WrapWithCanceled(vald.GetObjectRPCName+" API for "+vald.UpdateRPCName+" API canceled", err, reqInfo, resInfo) - attrs = trace.StatusCodeCancelled(err.Error()) - case errors.Is(err, context.DeadlineExceeded): - err = status.WrapWithDeadlineExceeded(vald.GetObjectRPCName+" API for "+vald.UpdateRPCName+" API deadline exceeded", err, reqInfo, resInfo) - attrs = trace.StatusCodeDeadlineExceeded(err.Error()) - case errors.Is(err, errors.ErrObjectIDNotFound(uuid)), errors.Is(err, errors.ErrObjectNotFound(nil, uuid)): - err = status.WrapWithNotFound(vald.GetObjectRPCName+" API for "+vald.UpdateRPCName+" API uuid "+uuid+"'s object not found", err, reqInfo, resInfo) - attrs = trace.StatusCodeNotFound(err.Error()) - default: - code := codes.Unknown - if err == nil { - err = errors.ErrObjectIDNotFound(uuid) - code = codes.NotFound - } - st, msg, err = status.ParseError(err, code, vald.GetObjectRPCName+" API for "+vald.UpdateRPCName+" API uuid "+uuid+"'s request returned error", reqInfo, resInfo) - attrs = trace.FromGRPCStatus(st.Code(), msg) - } - if span != nil { + vec, err := s.GetObject(ctx, &payload.Object_VectorRequest{ + Id: &payload.Object_ID{ + Id: uuid, + }, + }) + if err != nil { + st, msg, err := status.ParseError(err, codes.Unknown, vald.GetObjectRPCName+" API for "+vald.UpdateRPCName+" API uuid "+uuid+"'s request returned error", reqInfo, resInfo) + if span != nil && st != nil { span.RecordError(err) - span.SetAttributes(attrs...) + span.SetAttributes(trace.FromGRPCStatus(st.Code(), msg)...) span.SetStatus(trace.StatusError, err.Error()) } return nil, err @@ -2121,6 +2007,221 @@ func (s *server) MultiUpdate( return locs, errs } +func (s *server) UpdateTimestamp( + ctx context.Context, req *payload.Object_Timestamp, +) (res *payload.Object_Location, err error) { + ctx, span := trace.StartSpan(grpc.WithGRPCMethod(ctx, vald.PackageName+"."+vald.UpdateRPCServiceName+"/"+vald.UpdateTimestampRPCName), apiName+"/"+vald.UpdateTimestampRPCName) + defer func() { + if span != nil { + span.End() + } + }() + uuid := req.GetId() + reqInfo := &errdetails.RequestInfo{ + RequestId: uuid, + ServingData: errdetails.Serialize(req), + } + resInfo := &errdetails.ResourceInfo{ + ResourceType: errdetails.ValdGRPCResourceTypePrefix + "/vald.v1." + vald.UpdateTimestampRPCName + "." + vald.GetObjectRPCName, + ResourceName: fmt.Sprintf("%s: %s(%s) to %v", apiName, s.name, s.ip, s.gateway.Addrs(ctx)), + } + if len(uuid) == 0 { + err = errors.ErrInvalidMetaDataConfig + err = status.WrapWithInvalidArgument(vald.UpdateTimestampRPCName+" API invalid uuid", err, reqInfo, resInfo, + &errdetails.BadRequest{ + FieldViolations: []*errdetails.BadRequestFieldViolation{ + { + Field: "invalid id", + Description: err.Error(), + }, + }, + }) + if span != nil { + span.RecordError(err) + span.SetAttributes(trace.StatusCodeInvalidArgument(err.Error())...) + span.SetStatus(trace.StatusError, err.Error()) + } + return nil, err + } + ts := req.GetTimestamp() + if ts < 0 { + err = errors.ErrInvalidTimestamp(ts) + err = status.WrapWithInvalidArgument(vald.UpdateTimestampRPCName+" API invalid vector argument", err, reqInfo, resInfo, + &errdetails.BadRequest{ + FieldViolations: []*errdetails.BadRequestFieldViolation{ + { + Field: "timestamp", + Description: err.Error(), + }, + }, + }, info.Get()) + if span != nil { + span.RecordError(err) + span.SetAttributes(trace.StatusCodeInvalidArgument(err.Error())...) + span.SetStatus(trace.StatusError, err.Error()) + } + return nil, err + } + var ( + mu sync.RWMutex + aeCount atomic.Uint64 + updated atomic.Uint64 + ls = make([]string, 0, s.replica) + visited = make(map[string]bool, s.replica) + locs = &payload.Object_Location{ + Uuid: uuid, + Ips: make([]string, 0, s.replica), + } + ) + err = s.gateway.BroadCast(ctx, service.WRITE, func(ctx context.Context, target string, vc vald.Client, copts ...grpc.CallOption) (err error) { + ctx, span := trace.StartSpan(grpc.WrapGRPCMethod(ctx, "BroadCast/"+target), apiName+"/"+vald.UpdateRPCName+"/"+target) + defer func() { + if span != nil { + span.End() + } + }() + loc, err := vc.UpdateTimestamp(ctx, req, copts...) + if err != nil { + st, ok := status.FromError(err) + if ok && st != nil { + if st.Code() != codes.AlreadyExists && + st.Code() != codes.Canceled && + st.Code() != codes.DeadlineExceeded && + st.Code() != codes.InvalidArgument && + st.Code() != codes.NotFound && + st.Code() != codes.OK && + st.Code() != codes.Unimplemented { + if span != nil { + span.RecordError(err) + span.SetAttributes(trace.FromGRPCStatus(st.Code(), fmt.Sprintf("UpdateTimestamp operation for Agent %s failed,\terror: %v", target, err))...) + span.SetStatus(trace.StatusError, err.Error()) + } + return err + } + if st.Code() == codes.AlreadyExists { + host, _, err := net.SplitHostPort(target) + if err != nil { + host = target + } + aeCount.Add(1) + mu.Lock() + visited[target] = true + locs.Ips = append(locs.GetIps(), host) + ls = append(ls, host) + mu.Unlock() + + } + } + return nil + } + if loc != nil { + updated.Add(1) + mu.Lock() + visited[target] = true + locs.Ips = append(locs.GetIps(), loc.GetIps()...) + ls = append(ls, loc.GetName()) + mu.Unlock() + } + return nil + }) + switch { + case err != nil: + st, msg, err := status.ParseError(err, codes.Internal, + "failed to parse "+vald.UpdateRPCName+" gRPC error response", reqInfo, resInfo, info.Get()) + if span != nil { + span.RecordError(err) + span.SetAttributes(trace.FromGRPCStatus(st.Code(), msg)...) + span.SetStatus(trace.StatusError, err.Error()) + } + return nil, err + case len(locs.Ips) <= 0: + err = errors.ErrIndexNotFound + err = status.WrapWithNotFound(vald.UpdateRPCName+" API update target not found", err, reqInfo, resInfo) + if span != nil { + span.RecordError(err) + span.SetAttributes(trace.StatusCodeNotFound(err.Error())...) + span.SetStatus(trace.StatusError, err.Error()) + } + return nil, err + case updated.Load()+aeCount.Load() < uint64(s.replica): + shortage := s.replica - int(updated.Load()+aeCount.Load()) + vec, err := s.GetObject(ctx, &payload.Object_VectorRequest{ + Id: &payload.Object_ID{ + Id: uuid, + }, + }) + if err != nil { + st, msg, err := status.ParseError(err, codes.Unknown, vald.GetObjectRPCName+" API for "+vald.UpdateTimestampRPCName+" API uuid "+uuid+"'s request returned error", reqInfo, resInfo) + if span != nil && st != nil { + span.RecordError(err) + span.SetAttributes(trace.FromGRPCStatus(st.Code(), msg)...) + span.SetStatus(trace.StatusError, err.Error()) + } + return nil, err + } + + err = s.gateway.DoMulti(ctx, shortage, func(ctx context.Context, target string, vc vald.Client, copts ...grpc.CallOption) (err error) { + mu.RLock() + tf, ok := visited[target] + mu.RUnlock() + if tf && ok { + return errors.Errorf("target: %s already inserted will skip", target) + } + ctx, span := trace.StartSpan(grpc.WrapGRPCMethod(ctx, "DoMulti/"+target), apiName+"/"+vald.InsertRPCName+"/"+target) + defer func() { + if span != nil { + span.End() + } + }() + loc, err := vc.Insert(ctx, &payload.Insert_Request{ + Vector: vec, + Config: &payload.Insert_Config{ + SkipStrictExistCheck: true, + Timestamp: ts, + }, + }, copts...) + if err != nil { + st, ok := status.FromError(err) + if ok && st != nil && span != nil { + span.RecordError(err) + span.SetAttributes(trace.FromGRPCStatus(st.Code(), fmt.Sprintf("Shortage index Insert for Update operation for Agent %s failed,\terror: %v", target, err))...) + span.SetStatus(trace.StatusError, err.Error()) + } + return err + } + if loc != nil { + updated.Add(1) + mu.Lock() + locs.Ips = append(locs.GetIps(), loc.GetIps()...) + ls = append(ls, loc.GetName()) + mu.Unlock() + } + return nil + }) + if err != nil { + st, msg, err := status.ParseError(err, codes.Unknown, vald.InsertRPCName+" API for "+vald.UpdateRPCName+" API uuid "+uuid+"'s request returned error", reqInfo, resInfo) + if span != nil && st != nil { + span.RecordError(err) + span.SetAttributes(trace.FromGRPCStatus(st.Code(), msg)...) + span.SetStatus(trace.StatusError, err.Error()) + } + return nil, err + } + case updated.Load() == 0 && aeCount.Load() > 0: + err = status.WrapWithAlreadyExists(vald.UpdateRPCName+" API update target same vector already exists", errors.ErrSameVectorAlreadyExists(uuid, nil, nil), reqInfo, resInfo) + if span != nil { + span.RecordError(err) + span.SetAttributes(trace.StatusCodeAlreadyExists(err.Error())...) + span.SetStatus(trace.StatusError, err.Error()) + } + return nil, err + + } + slices.Sort(ls) + locs.Name = strings.Join(ls, ",") + return locs, nil +} + func (s *server) Upsert( ctx context.Context, req *payload.Upsert_Request, ) (loc *payload.Object_Location, err error) { @@ -2180,48 +2281,23 @@ func (s *server) Upsert( } var shouldInsert bool if !req.GetConfig().GetSkipStrictExistCheck() { - vec, err := s.getObject(ctx, uuid) - var ( - attrs trace.Attributes - st *status.Status - msg string - ) + vec, err := s.GetObject(ctx, &payload.Object_VectorRequest{ + Id: &payload.Object_ID{ + Id: uuid, + }, + }) + var attrs trace.Attributes if err != nil || vec == nil { - switch { - case errors.Is(err, errors.ErrInvalidUUID(uuid)): - err = status.WrapWithInvalidArgument( - vald.GetObjectRPCName+" API for "+vald.UpsertRPCName+" API invalid argument for uuid \""+uuid+"\" detected", - err, - reqInfo, - resInfo, - &errdetails.BadRequest{ - FieldViolations: []*errdetails.BadRequestFieldViolation{ - { - Field: "uuid", - Description: err.Error(), - }, - }, - }, - ) - attrs = trace.StatusCodeInvalidArgument(err.Error()) - case errors.Is(err, errors.ErrGRPCClientConnNotFound("*")): - err = status.WrapWithInternal(vald.GetObjectRPCName+" API for "+vald.UpsertRPCName+" API connection not found", err, reqInfo, resInfo) - attrs = trace.StatusCodeInternal(err.Error()) - case errors.Is(err, context.Canceled): - err = status.WrapWithCanceled(vald.GetObjectRPCName+" API for "+vald.UpsertRPCName+" API canceled", err, reqInfo, resInfo) - attrs = trace.StatusCodeCancelled(err.Error()) - case errors.Is(err, context.DeadlineExceeded): - err = status.WrapWithDeadlineExceeded(vald.GetObjectRPCName+" API for "+vald.UpsertRPCName+" API deadline exceeded", err, reqInfo, resInfo) - attrs = trace.StatusCodeDeadlineExceeded(err.Error()) - case errors.Is(err, errors.ErrObjectIDNotFound(uuid)), errors.Is(err, errors.ErrObjectNotFound(nil, uuid)): - err = nil - shouldInsert = true - default: - st, msg, err = status.ParseError(err, codes.Unknown, vald.GetObjectRPCName+" API for "+vald.UpsertRPCName+" API uuid "+uuid+"'s request returned error", reqInfo, resInfo) + var ( + st *status.Status + msg string + ) + st, msg, err = status.ParseError(err, codes.Unknown, vald.GetObjectRPCName+" API for "+vald.UpsertRPCName+" API uuid "+uuid+"'s request returned error", reqInfo, resInfo) + if st != nil { attrs = trace.FromGRPCStatus(st.Code(), msg) - if st != nil && st.Code() == codes.NotFound { - err = nil + if st.Code() == codes.NotFound { shouldInsert = true + err = nil } } } else if conv.F32stos(vec.GetVector()) == conv.F32stos(req.GetVector().GetVector()) { @@ -2236,7 +2312,6 @@ func (s *server) Upsert( } return nil, err } - } else { id, err := s.exists(ctx, uuid) if err != nil { diff --git a/pkg/gateway/lb/service/gateway.go b/pkg/gateway/lb/service/gateway.go index 53c259c9e1..2d806b20fc 100644 --- a/pkg/gateway/lb/service/gateway.go +++ b/pkg/gateway/lb/service/gateway.go @@ -24,6 +24,7 @@ import ( "github.com/vdaas/vald/apis/grpc/v1/vald" "github.com/vdaas/vald/internal/client/v1/client/discoverer" + vc "github.com/vdaas/vald/internal/client/v1/client/vald" "github.com/vdaas/vald/internal/errors" "github.com/vdaas/vald/internal/net/grpc" "github.com/vdaas/vald/internal/observability/trace" @@ -94,7 +95,7 @@ func (g *gateway) BroadCast( case <-ictx.Done(): return nil default: - err = f(ictx, addr, vald.NewValdClient(conn), copts...) + err = f(ictx, addr, vc.NewValdClient(conn), copts...) if err != nil { return err } @@ -129,7 +130,7 @@ func (g *gateway) DoMulti( copts ...grpc.CallOption, ) (err error) { if atomic.LoadUint32(&cur) < limit { - err = f(ictx, addr, vald.NewValdClient(conn), copts...) + err = f(ictx, addr, vc.NewValdClient(conn), copts...) if err != nil { return err } @@ -147,7 +148,7 @@ func (g *gateway) DoMulti( if atomic.LoadUint32(&cur) < limit { _, ok := visited.Load(addr) if !ok { - err = f(ictx, addr, vald.NewValdClient(conn), copts...) + err = f(ictx, addr, vc.NewValdClient(conn), copts...) if err != nil { return err } diff --git a/pkg/gateway/mirror/handler/grpc/handler.go b/pkg/gateway/mirror/handler/grpc/handler.go index 45226b4806..7065b1e177 100644 --- a/pkg/gateway/mirror/handler/grpc/handler.go +++ b/pkg/gateway/mirror/handler/grpc/handler.go @@ -1173,7 +1173,7 @@ func (s *server) handleInsert( } // In this case, the status code in the result object contains only OK or ALREADY_EXIST. - // And send Update API requst to ALREADY_EXIST cluster using the query requested by the user. + // And send Update API request to ALREADY_EXIST cluster using the query requested by the user. log.Warnf("failed to "+vald.InsertRPCName+" API: %#v", err) resLoc, err := s.handleInsertResult(ctx, alreadyExistsTgts, &payload.Update_Request{ @@ -1743,7 +1743,7 @@ func (s *server) handleUpdate( } // In this case, the status code in the result object contains only OK or ALREADY_EXIST or NOT_FOUND. - // And send Insert API requst to NOT_FOUND cluster using query requested by the user. + // And send Insert API request to NOT_FOUND cluster using query requested by the user. log.Warnf("failed to "+vald.UpdateRPCName+" API: %#v", err) resLoc, err := s.handleUpdateResult(ctx, notFoundTgts, &payload.Insert_Request{ @@ -2382,7 +2382,7 @@ func (s *server) doUpsert( return loc, nil } -// StreamUpsert handles bidirectional streaming for upserting objects. +// StreamUpsert handles bidirectional streaming for upsert objects. // It wraps the bidirectional stream logic for the Upsert RPC method. // For each incoming request in the bidirectional stream, it calls the Upsert function. // The response is then sent back through the stream with the corresponding status or location information. @@ -3348,7 +3348,7 @@ func (s *server) doStreamListObject( err = status.WrapWithCanceled("Stream Recv returned canceld error at "+id, err) attr = trace.StatusCodeCancelled(err.Error()) case errors.Is(err, context.DeadlineExceeded): - err = status.WrapWithDeadlineExceeded("Stream Recv returned deadlin exceeded error at "+id, err) + err = status.WrapWithDeadlineExceeded("Stream Recv returned deadline exceeded error at "+id, err) attr = trace.StatusCodeDeadlineExceeded(err.Error()) default: var ( @@ -3387,7 +3387,7 @@ func (s *server) doStreamListObject( err = status.WrapWithCanceled("Stream Send returned canceld error at "+id, err) attr = trace.StatusCodeCancelled(err.Error()) case errors.Is(err, context.DeadlineExceeded): - err = status.WrapWithDeadlineExceeded("Stream Send returned deadlin exceeded error at "+id, err) + err = status.WrapWithDeadlineExceeded("Stream Send returned deadline exceeded error at "+id, err) attr = trace.StatusCodeDeadlineExceeded(err.Error()) default: var ( diff --git a/pkg/gateway/mirror/service/mirror.go b/pkg/gateway/mirror/service/mirror.go index b5ab31609b..5a2e68c920 100644 --- a/pkg/gateway/mirror/service/mirror.go +++ b/pkg/gateway/mirror/service/mirror.go @@ -64,10 +64,10 @@ func NewMirrorClient(conn *grpc.ClientConn) MirrorClient { } type mirr struct { - addrl sync.Map[string, any] // List of all connected addresses + addrs sync.Map[string, any] // List of all connected addresses selfMirrTgts []*payload.Mirror_Target // Targets of self mirror gateway - selfMirrAddrl sync.Map[string, any] // List of self Mirror gateway addresses - gwAddrl sync.Map[string, any] // List of Vald gateway (LB gateway) addresses + selfMirrAddrs sync.Map[string, any] // List of self Mirror gateway addresses + gwAddrs sync.Map[string, any] // List of Vald gateway (LB gateway) addresses eg errgroup.Group registerDur time.Duration gateway Gateway @@ -90,7 +90,7 @@ func NewMirror(opts ...MirrorOption) (_ Mirror, err error) { } m.selfMirrTgts = make([]*payload.Mirror_Target, 0) - m.selfMirrAddrl.Range(func(addr string, _ any) bool { + m.selfMirrAddrs.Range(func(addr string, _ any) bool { var ( host string port uint16 @@ -317,15 +317,15 @@ func (m *mirr) Connect(ctx context.Context, targets ...*payload.Mirror_Target) e for _, target := range targets { addr := net.JoinHostPort(target.GetHost(), uint16(target.GetPort())) // addr: host:port if !m.isSelfMirrorAddr(addr) && !m.isGatewayAddr(addr) { - _, ok := m.addrl.Load(addr) + _, ok := m.addrs.Load(addr) if !ok || !m.IsConnected(ctx, addr) { _, err := m.gateway.GRPCClient().Connect(ctx, addr) if err != nil { - m.addrl.Delete(addr) + m.addrs.Delete(addr) return err } } - m.addrl.Store(addr, struct{}{}) + m.addrs.Store(addr, struct{}{}) } } return nil @@ -345,13 +345,13 @@ func (m *mirr) Disconnect(ctx context.Context, targets ...*payload.Mirror_Target for _, target := range targets { addr := net.JoinHostPort(target.GetHost(), uint16(target.GetPort())) if !m.isGatewayAddr(addr) { - _, ok := m.addrl.Load(addr) + _, ok := m.addrs.Load(addr) if ok || m.IsConnected(ctx, addr) { if err := m.gateway.GRPCClient().Disconnect(ctx, addr); err != nil && !errors.Is(err, errors.ErrGRPCClientConnNotFound(addr)) { return err } - m.addrl.Delete(addr) + m.addrs.Delete(addr) } } } @@ -366,7 +366,7 @@ func (m *mirr) IsConnected(ctx context.Context, addr string) bool { // MirrorTargets returns the Mirror targets, including the address of this gateway and the addresses of other Mirror gateways // to which this gateway is currently connected. func (m *mirr) MirrorTargets(ctx context.Context) (tgts []*payload.Mirror_Target, err error) { - tgts = make([]*payload.Mirror_Target, 0, m.addrl.Len()) + tgts = make([]*payload.Mirror_Target, 0, m.addrs.Len()) m.RangeMirrorAddr(func(addr string, _ any) bool { if m.IsConnected(ctx, addr) { var ( @@ -391,12 +391,12 @@ func (m *mirr) MirrorTargets(ctx context.Context) (tgts []*payload.Mirror_Target } func (m *mirr) isSelfMirrorAddr(addr string) bool { - _, ok := m.selfMirrAddrl.Load(addr) + _, ok := m.selfMirrAddrs.Load(addr) return ok } func (m *mirr) isGatewayAddr(addr string) bool { - _, ok := m.gwAddrl.Load(addr) + _, ok := m.gwAddrs.Load(addr) return ok } @@ -413,7 +413,7 @@ func (m *mirr) connectedOtherMirrorAddrs(ctx context.Context) (addrs []string) { // RangeMirrorAddr calls f sequentially for each key and value present in the connection map. If f returns false, range stops the iteration. func (m *mirr) RangeMirrorAddr(f func(addr string, _ any) bool) { - m.addrl.Range(func(addr string, value any) bool { + m.addrs.Range(func(addr string, value any) bool { if !m.isGatewayAddr(addr) && !m.isSelfMirrorAddr(addr) { if !f(addr, value) { return false diff --git a/pkg/gateway/mirror/service/mirror_option.go b/pkg/gateway/mirror/service/mirror_option.go index 1b7243c382..ed605911eb 100644 --- a/pkg/gateway/mirror/service/mirror_option.go +++ b/pkg/gateway/mirror/service/mirror_option.go @@ -44,7 +44,7 @@ func WithGatewayAddrs(addrs ...string) MirrorOption { return errors.NewErrCriticalOption("lbAddrs", addrs) } for _, addr := range addrs { - m.gwAddrl.Store(addr, struct{}{}) + m.gwAddrs.Store(addr, struct{}{}) } return nil } @@ -57,7 +57,7 @@ func WithSelfMirrorAddrs(addrs ...string) MirrorOption { return errors.NewErrCriticalOption("selfMirrorAddrs", addrs) } for _, addr := range addrs { - m.selfMirrAddrl.Store(addr, struct{}{}) + m.selfMirrAddrs.Store(addr, struct{}{}) } return nil } diff --git a/pkg/gateway/mirror/service/mirror_test.go b/pkg/gateway/mirror/service/mirror_test.go index d23f204fcd..edf41c8191 100644 --- a/pkg/gateway/mirror/service/mirror_test.go +++ b/pkg/gateway/mirror/service/mirror_test.go @@ -734,10 +734,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // ctx context.Context // } // type fields struct { -// addrl sync.Map[string, any] +// addrs sync.Map[string, any] // selfMirrTgts []*payload.Mirror_Target -// selfMirrAddrl sync.Map[string, any] -// gwAddrl sync.Map[string, any] +// selfMirrAddrs sync.Map[string, any] +// gwAddrs sync.Map[string, any] // eg errgroup.Group // registerDur time.Duration // gateway Gateway @@ -769,10 +769,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // ctx:nil, // }, // fields: fields { -// addrl:nil, +// addrs:nil, // selfMirrTgts:nil, -// selfMirrAddrl:nil, -// gwAddrl:nil, +// selfMirrAddrs:nil, +// gwAddrs:nil, // eg:nil, // registerDur:nil, // gateway:nil, @@ -797,10 +797,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // ctx:nil, // }, // fields: fields { -// addrl:nil, +// addrs:nil, // selfMirrTgts:nil, -// selfMirrAddrl:nil, -// gwAddrl:nil, +// selfMirrAddrs:nil, +// gwAddrs:nil, // eg:nil, // registerDur:nil, // gateway:nil, @@ -834,10 +834,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // checkFunc = defaultCheckFunc // } // m := &mirr{ -// addrl: test.fields.addrl, +// addrs: test.fields.addrs, // selfMirrTgts: test.fields.selfMirrTgts, -// selfMirrAddrl: test.fields.selfMirrAddrl, -// gwAddrl: test.fields.gwAddrl, +// selfMirrAddrs: test.fields.selfMirrAddrs, +// gwAddrs: test.fields.gwAddrs, // eg: test.fields.eg, // registerDur: test.fields.registerDur, // gateway: test.fields.gateway, @@ -857,10 +857,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // tgts *payload.Mirror_Targets // } // type fields struct { -// addrl sync.Map[string, any] +// addrs sync.Map[string, any] // selfMirrTgts []*payload.Mirror_Target -// selfMirrAddrl sync.Map[string, any] -// gwAddrl sync.Map[string, any] +// selfMirrAddrs sync.Map[string, any] +// gwAddrs sync.Map[string, any] // eg errgroup.Group // registerDur time.Duration // gateway Gateway @@ -897,10 +897,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // tgts:nil, // }, // fields: fields { -// addrl:nil, +// addrs:nil, // selfMirrTgts:nil, -// selfMirrAddrl:nil, -// gwAddrl:nil, +// selfMirrAddrs:nil, +// gwAddrs:nil, // eg:nil, // registerDur:nil, // gateway:nil, @@ -926,10 +926,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // tgts:nil, // }, // fields: fields { -// addrl:nil, +// addrs:nil, // selfMirrTgts:nil, -// selfMirrAddrl:nil, -// gwAddrl:nil, +// selfMirrAddrs:nil, +// gwAddrs:nil, // eg:nil, // registerDur:nil, // gateway:nil, @@ -963,10 +963,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // checkFunc = defaultCheckFunc // } // m := &mirr{ -// addrl: test.fields.addrl, +// addrs: test.fields.addrs, // selfMirrTgts: test.fields.selfMirrTgts, -// selfMirrAddrl: test.fields.selfMirrAddrl, -// gwAddrl: test.fields.gwAddrl, +// selfMirrAddrs: test.fields.selfMirrAddrs, +// gwAddrs: test.fields.gwAddrs, // eg: test.fields.eg, // registerDur: test.fields.registerDur, // gateway: test.fields.gateway, @@ -986,10 +986,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // addr string // } // type fields struct { -// addrl sync.Map[string, any] +// addrs sync.Map[string, any] // selfMirrTgts []*payload.Mirror_Target -// selfMirrAddrl sync.Map[string, any] -// gwAddrl sync.Map[string, any] +// selfMirrAddrs sync.Map[string, any] +// gwAddrs sync.Map[string, any] // eg errgroup.Group // registerDur time.Duration // gateway Gateway @@ -1022,10 +1022,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // addr:"", // }, // fields: fields { -// addrl:nil, +// addrs:nil, // selfMirrTgts:nil, -// selfMirrAddrl:nil, -// gwAddrl:nil, +// selfMirrAddrs:nil, +// gwAddrs:nil, // eg:nil, // registerDur:nil, // gateway:nil, @@ -1051,10 +1051,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // addr:"", // }, // fields: fields { -// addrl:nil, +// addrs:nil, // selfMirrTgts:nil, -// selfMirrAddrl:nil, -// gwAddrl:nil, +// selfMirrAddrs:nil, +// gwAddrs:nil, // eg:nil, // registerDur:nil, // gateway:nil, @@ -1088,10 +1088,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // checkFunc = defaultCheckFunc // } // m := &mirr{ -// addrl: test.fields.addrl, +// addrs: test.fields.addrs, // selfMirrTgts: test.fields.selfMirrTgts, -// selfMirrAddrl: test.fields.selfMirrAddrl, -// gwAddrl: test.fields.gwAddrl, +// selfMirrAddrs: test.fields.selfMirrAddrs, +// gwAddrs: test.fields.gwAddrs, // eg: test.fields.eg, // registerDur: test.fields.registerDur, // gateway: test.fields.gateway, @@ -1110,10 +1110,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // addr string // } // type fields struct { -// addrl sync.Map[string, any] +// addrs sync.Map[string, any] // selfMirrTgts []*payload.Mirror_Target -// selfMirrAddrl sync.Map[string, any] -// gwAddrl sync.Map[string, any] +// selfMirrAddrs sync.Map[string, any] +// gwAddrs sync.Map[string, any] // eg errgroup.Group // registerDur time.Duration // gateway Gateway @@ -1145,10 +1145,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // addr:"", // }, // fields: fields { -// addrl:nil, +// addrs:nil, // selfMirrTgts:nil, -// selfMirrAddrl:nil, -// gwAddrl:nil, +// selfMirrAddrs:nil, +// gwAddrs:nil, // eg:nil, // registerDur:nil, // gateway:nil, @@ -1173,10 +1173,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // addr:"", // }, // fields: fields { -// addrl:nil, +// addrs:nil, // selfMirrTgts:nil, -// selfMirrAddrl:nil, -// gwAddrl:nil, +// selfMirrAddrs:nil, +// gwAddrs:nil, // eg:nil, // registerDur:nil, // gateway:nil, @@ -1210,10 +1210,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // checkFunc = defaultCheckFunc // } // m := &mirr{ -// addrl: test.fields.addrl, +// addrs: test.fields.addrs, // selfMirrTgts: test.fields.selfMirrTgts, -// selfMirrAddrl: test.fields.selfMirrAddrl, -// gwAddrl: test.fields.gwAddrl, +// selfMirrAddrs: test.fields.selfMirrAddrs, +// gwAddrs: test.fields.gwAddrs, // eg: test.fields.eg, // registerDur: test.fields.registerDur, // gateway: test.fields.gateway, @@ -1232,10 +1232,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // addr string // } // type fields struct { -// addrl sync.Map[string, any] +// addrs sync.Map[string, any] // selfMirrTgts []*payload.Mirror_Target -// selfMirrAddrl sync.Map[string, any] -// gwAddrl sync.Map[string, any] +// selfMirrAddrs sync.Map[string, any] +// gwAddrs sync.Map[string, any] // eg errgroup.Group // registerDur time.Duration // gateway Gateway @@ -1267,10 +1267,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // addr:"", // }, // fields: fields { -// addrl:nil, +// addrs:nil, // selfMirrTgts:nil, -// selfMirrAddrl:nil, -// gwAddrl:nil, +// selfMirrAddrs:nil, +// gwAddrs:nil, // eg:nil, // registerDur:nil, // gateway:nil, @@ -1295,10 +1295,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // addr:"", // }, // fields: fields { -// addrl:nil, +// addrs:nil, // selfMirrTgts:nil, -// selfMirrAddrl:nil, -// gwAddrl:nil, +// selfMirrAddrs:nil, +// gwAddrs:nil, // eg:nil, // registerDur:nil, // gateway:nil, @@ -1332,10 +1332,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // checkFunc = defaultCheckFunc // } // m := &mirr{ -// addrl: test.fields.addrl, +// addrs: test.fields.addrs, // selfMirrTgts: test.fields.selfMirrTgts, -// selfMirrAddrl: test.fields.selfMirrAddrl, -// gwAddrl: test.fields.gwAddrl, +// selfMirrAddrs: test.fields.selfMirrAddrs, +// gwAddrs: test.fields.gwAddrs, // eg: test.fields.eg, // registerDur: test.fields.registerDur, // gateway: test.fields.gateway, @@ -1354,10 +1354,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // f func(addr string, _ any) bool // } // type fields struct { -// addrl sync.Map[string, any] +// addrs sync.Map[string, any] // selfMirrTgts []*payload.Mirror_Target -// selfMirrAddrl sync.Map[string, any] -// gwAddrl sync.Map[string, any] +// selfMirrAddrs sync.Map[string, any] +// gwAddrs sync.Map[string, any] // eg errgroup.Group // registerDur time.Duration // gateway Gateway @@ -1384,10 +1384,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // f:nil, // }, // fields: fields { -// addrl:nil, +// addrs:nil, // selfMirrTgts:nil, -// selfMirrAddrl:nil, -// gwAddrl:nil, +// selfMirrAddrs:nil, +// gwAddrs:nil, // eg:nil, // registerDur:nil, // gateway:nil, @@ -1412,10 +1412,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // f:nil, // }, // fields: fields { -// addrl:nil, +// addrs:nil, // selfMirrTgts:nil, -// selfMirrAddrl:nil, -// gwAddrl:nil, +// selfMirrAddrs:nil, +// gwAddrs:nil, // eg:nil, // registerDur:nil, // gateway:nil, @@ -1449,10 +1449,10 @@ func Test_mirr_connectedOtherMirrorAddrs(t *testing.T) { // checkFunc = defaultCheckFunc // } // m := &mirr{ -// addrl: test.fields.addrl, +// addrs: test.fields.addrs, // selfMirrTgts: test.fields.selfMirrTgts, -// selfMirrAddrl: test.fields.selfMirrAddrl, -// gwAddrl: test.fields.gwAddrl, +// selfMirrAddrs: test.fields.selfMirrAddrs, +// gwAddrs: test.fields.gwAddrs, // eg: test.fields.eg, // registerDur: test.fields.registerDur, // gateway: test.fields.gateway, diff --git a/pkg/gateway/mirror/usecase/vald.go b/pkg/gateway/mirror/usecase/vald.go index 453c7344c4..12976fda0e 100644 --- a/pkg/gateway/mirror/usecase/vald.go +++ b/pkg/gateway/mirror/usecase/vald.go @@ -23,9 +23,9 @@ import ( "github.com/vdaas/vald/internal/net" "github.com/vdaas/vald/internal/net/grpc" "github.com/vdaas/vald/internal/observability" - bometrics "github.com/vdaas/vald/internal/observability/metrics/backoff" + backoffmetrics "github.com/vdaas/vald/internal/observability/metrics/backoff" cbmetrics "github.com/vdaas/vald/internal/observability/metrics/circuitbreaker" - mirrmetrics "github.com/vdaas/vald/internal/observability/metrics/gateway/mirror" + mirrormetrics "github.com/vdaas/vald/internal/observability/metrics/gateway/mirror" "github.com/vdaas/vald/internal/runner" "github.com/vdaas/vald/internal/safety" "github.com/vdaas/vald/internal/servers/server" @@ -135,9 +135,9 @@ func New(cfg *config.Data) (r runner.Runner, err error) { if cfg.Observability.Enabled { obs, err = observability.NewWithConfig( cfg.Observability, - bometrics.New(), + backoffmetrics.New(), cbmetrics.New(), - mirrmetrics.New(m), + mirrormetrics.New(m), ) if err != nil { return nil, err diff --git a/pkg/index/job/correction/service/corrector.go b/pkg/index/job/correction/service/corrector.go index 41a71b2274..b293b8b92c 100644 --- a/pkg/index/job/correction/service/corrector.go +++ b/pkg/index/job/correction/service/corrector.go @@ -87,7 +87,7 @@ func New(opts ...Option) (_ Corrector, err error) { log.Errorf("failed to create dir %s", dir) return nil, err } - path := file.Join(dir, "checkedid.db") + path := file.Join(dir, "checked_id.db") db, err := pogreb.New(pogreb.WithPath(path), pogreb.WithBackgroundCompactionInterval(c.backgroundCompactionInterval), pogreb.WithBackgroundSyncInterval(c.backgroundSyncInterval)) @@ -136,15 +136,22 @@ func (c *correct) Start(ctx context.Context) (err error) { return err } counts := detail.GetCounts() - agents := make([]string, 0, detail.GetLiveAgents()) - for agent, count := range counts { - log.Infof("index info: addr(%s), stored(%d), uncommitted(%d), indexing=%t, saving=%t", agent, count.GetStored(), count.GetUncommitted(), count.GetIndexing(), count.GetSaving()) + agents := make([]string, 0, len(counts)) + for agent := range counts { agents = append(agents, agent) } slices.SortFunc(agents, func(left, right string) int { - return cmp.Compare(counts[left].GetStored(), counts[right].GetStored()) + return cmp.Compare(counts[right].GetStored(), counts[left].GetStored()) }) + for _, agent := range agents { + count, ok := counts[agent] + if ok && count != nil { + log.Infof("index info: addr(%s), stored(%d), uncommitted(%d), indexing=%t, saving=%t", agent, count.GetStored(), count.GetUncommitted(), count.GetIndexing(), count.GetSaving()) + } + } + log.Infof("sorted agents: %v,\tdiscovered agents: %v", agents, c.discoverer.GetAddrs(ctx)) + errs := make([]error, 0, len(agents)) emptyReq := new(payload.Object_List_Request) @@ -177,24 +184,26 @@ func (c *correct) Start(ctx context.Context) (err error) { uncommitted uint32 indexing bool saving bool + debugMsg string ) count, ok := counts[addr] if ok && count != nil { stored = count.GetStored() uncommitted = count.GetUncommitted() + indexing = count.GetIndexing() + saving = count.GetSaving() + debugMsg = fmt.Sprintf("agent %s (total index detail = stored: %d, uncommitted: %d, indexing=%t, saving=%t), stream concurrency: %d, processing %d/%d, replicas: size(%d) = addrs%v", addr, stored, uncommitted, indexing, saving, c.streamListConcurrency, corrected, len(agents), len(replicas), replicas) if stored+uncommitted == 0 { // id no indices in agent skip process + log.Warnf("skipping index correction process due to zero index detected for %s", debugMsg) return nil } - indexing = count.GetIndexing() - saving = count.GetSaving() } - debugMsg := fmt.Sprintf("agent %s (stored: %d, uncommitted: %d, indexing=%t, saving=%t), stream concurrency: %d, processing %d/%d, replicas: size(%d) = addrs%v", addr, stored, uncommitted, indexing, saving, c.streamListConcurrency, corrected, len(agents), len(replicas), replicas) eg, egctx := errgroup.WithContext(ctx) eg.SetLimit(c.streamListConcurrency) ctx, cancel := context.WithCancelCause(egctx) - stream, err := vald.NewObjectClient(conn).StreamListObject(ctx, emptyReq, copts...) + stream, err := vc.NewValdClient(conn).StreamListObject(ctx, emptyReq, copts...) if err != nil { return err } @@ -225,27 +234,12 @@ func (c *correct) Start(ctx context.Context) (err error) { } else { cancel(errors.ErrStreamListObjectStreamFinishedUnexpectedly(err)) } - } else { + } else if res != nil && res.GetVector() != nil && res.GetVector().GetId() != "" && res.GetVector().GetTimestamp() < start.UnixNano() { eg.Go(safety.RecoverFunc(func() (err error) { vec := res.GetVector() - if vec == nil || vec.GetId() == "" { - st := res.GetStatus() - if st != nil { - log.Errorf("invalid vector id: %s detected and returned status code: %d, message: %s, details: %v, debug: %s", vec.GetId(), st.GetCode(), st.GetMessage(), st.GetDetails(), debugMsg) - } - return errors.ErrFailedToReceiveVectorFromStream - } - - // skip if the vector is inserted after correction start - if vec.GetTimestamp() > start.UnixNano() { - log.Debugf("index correction process for ID: %s skipped due to newer timestamp detected. job started at %s but object timestamp is %s", - vec.GetId(), - start.Format(time.RFC3339Nano), - time.Unix(0, vec.GetTimestamp()).Format(time.RFC3339Nano)) - return nil - } - + ts := vec.GetTimestamp() id := vec.GetId() + _, ok, err := c.checkedList.Get(id) if err != nil { log.Errorf("failed to perform Get from check list but still try to finish processing without cache: %v", err) @@ -264,161 +258,250 @@ func (c *correct) Start(ctx context.Context) (err error) { // Therefore, the process is only to correct the missing replicas. if len(replicas) <= 0 { diff := c.indexReplica - 1 - addrs := c.discoverer.GetAddrs(egctx) // correct index replica shortage if diff > 0 { - log.Infof("replica shortage(diff=%d) of vector id: %s detected from last %s. inserting to other agents = %v", diff, id, debugMsg, addrs) - if len(addrs) == 0 { - return errors.ErrNoAvailableAgentToInsert - } - req := &payload.Insert_Request{ - Vector: vec, - // TODO: this should be deleted after Config.Timestamp deprecation - Config: &payload.Insert_Config{ - Timestamp: vec.GetTimestamp(), - }, - } - for _, daddr := range addrs { - if diff > 0 && daddr != addr { - _, err := c.discoverer.GetClient().Do(grpc.WithGRPCMethod(egctx, vald.PackageName+"."+vald.InsertRPCServiceName+"/"+vald.InsertRPCName), daddr, func(ctx context.Context, - conn *grpc.ClientConn, - copts ...grpc.CallOption, - ) (any, error) { - client := vald.NewValdClient(conn) - _, err := client.Insert(ctx, req, copts...) - if err != nil { - if st, ok := status.FromError(err); !ok { - log.Errorf("gRPC call returned not a gRPC status error: %v", err) - return nil, err - } else if st.Code() == codes.AlreadyExists { - obj, err := client.GetObject(ctx, &payload.Object_VectorRequest{ - Id: &payload.Object_ID{ - Id: id, - }, - }, copts...) - if err != nil { - if st, ok = status.FromError(err); !ok { - log.Errorf("gRPC call returned not a gRPC status error: %v", err) - return nil, err - } else if st.Code() == codes.NotFound { - return nil, nil - } else if st.Code() == codes.Canceled { - return nil, nil - } - return nil, err - } - if obj.GetTimestamp() < vec.GetTimestamp() { - _, err := client.Update(ctx, &payload.Update_Request{ - Vector: vec, - // TODO: this should be deleted after Config.Timestamp deprecation - Config: &payload.Update_Config{ - // TODO: Decrementing because it's gonna be incremented befor being pushed - // to vqueue in the agent. This is a not ideal workaround for the current vqueue implementation - // so we should consider refactoring vqueue. - Timestamp: vec.GetTimestamp() - 1, - }, - }, copts...) - if err != nil { - if st, ok = status.FromError(err); !ok { - log.Errorf("gRPC call returned not a gRPC status error: %v", err) - return nil, err - } else if st.Code() == codes.NotFound { - return nil, nil - } else if st.Code() == codes.Canceled { - return nil, nil - } - return nil, err - } - c.correctedOldIndexCount.Add(1) - } - diff-- - c.correctedReplicationCount.Add(1) - return nil, nil - } else if st.Code() == codes.Canceled { - return nil, nil - } - return nil, err - } - diff-- - c.correctedReplicationCount.Add(1) - return nil, nil - }) - if err != nil { - log.Error(fmt.Errorf("failed to insert object to agent(%s): %w", daddr, err)) - } - } - } + return c.correctShortage(egctx, id, addr, debugMsg, vec, make(map[string]*payload.Object_Timestamp), diff) } return nil } - var ( - latest int64 - mu sync.Mutex - found = make(map[string]*payload.Object_Timestamp, len(addr)) - latestAgent = addr - ) // load index replica from other agents and store it to found map - if err := c.discoverer.GetClient().OrderedRangeConcurrent(egctx, replicas, len(replicas), - func(ctx context.Context, addr string, conn *grpc.ClientConn, copts ...grpc.CallOption) error { - ots, err := vald.NewObjectClient(conn).GetTimestamp(ctx, &payload.Object_TimestampRequest{ - Id: &payload.Object_ID{ - Id: id, - }, - }) - if err != nil { - if st, ok := status.FromError(err); !ok { - log.Errorf("gRPC call GetTimestamp to agent: %s, id: %s returned not a gRPC status error: %v", addr, id, err) - return err - } else if st.Code() == codes.NotFound { - // when replica of agent > index replica, this happens - return nil - } else if st.Code() == codes.Canceled { - return nil - } else { - log.Errorf("failed to GetTimestamp with unexpected error. agent: %s, id: %s, code: %v, message: %s", addr, id, st.Code(), st.Message()) - return err - } + found, skipped, latest, latestAgent, err := c.loadReplicaInfo(egctx, addr, id, replicas, counts, ts, start) + if err != nil { + return err + } + if len(found) != 0 && ((len(replicas) > 0 && len(skipped) == 0) || (len(skipped) > 0 && len(skipped) < len(replicas))) { + // current object timestamp is not latest get latest object from other agent index replica + if ts < latest && latestAgent != addr { + latestObject := c.getLatestObject(egctx, id, addr, latestAgent, latest) + if latestObject != nil && latestObject.GetVector() != nil && latestObject.GetId() != "" && latestObject.GetTimestamp() >= latest { + vec = latestObject } + } + c.correctTimestamp(ctx, id, vec, found) + } else if len(skipped) > 0 { + log.Debugf("timestamp correction for index id %s skipped, replica %s, skipped agents: %v", id, addr, skipped) + } + diff := c.indexReplica - (len(found) + 1) + if diff > 0 { // correct index replica shortage + return c.correctShortage(egctx, id, addr, debugMsg, vec, found, diff) + } else if diff < 0 { // correct index replica oversupply + return c.correctOversupply(egctx, id, addr, debugMsg, found, diff) + } + return nil + })) + } + } + } + }); err != nil { + // This only happens when ErrGRPCClientConnNotFound is returned. + // In other cases, OrderedRange continues processing, so error is used to keep track of the error status of correction. + errs = append(errs, err) + } + if len(errs) != 0 { + return errors.Join(errs...) + } - // skip if the vector is inserted after correction start - if ots.GetTimestamp() > start.UnixNano() { - log.Debugf("timestamp of vector(id: %s, timestamp: %v) is newer than correction start time(%v). skipping...", - ots.GetId(), - ots.GetTimestamp(), - start.UnixNano(), - ) - return nil - } - mu.Lock() - found[addr] = ots - if latest < ots.GetTimestamp() { - latest = ots.GetTimestamp() - if latest > vec.GetTimestamp() { - latestAgent = addr - } - } - mu.Unlock() - return nil + return nil +} + +func (c *correct) PreStop(_ context.Context) error { + log.Info("removing persistent cache files...") + return c.checkedList.Close(true) +} + +func (c *correct) NumberOfCheckedIndex() uint64 { + return c.checkedIndexCount.Load() +} + +func (c *correct) NumberOfCorrectedOldIndex() uint64 { + return c.correctedOldIndexCount.Load() +} + +func (c *correct) NumberOfCorrectedReplication() uint64 { + return c.correctedReplicationCount.Load() +} + +func (c *correct) loadReplicaInfo( + ctx context.Context, + originAddr, id string, + replicas []string, + counts map[string]*payload.Info_Index_Count, + ts int64, + start time.Time, +) ( + found map[string]*payload.Object_Timestamp, + skipped []string, + latest int64, + latestAgent string, + err error, +) { + var mu sync.Mutex + latestAgent = originAddr + skipped = make([]string, 0, len(replicas)) + found = make(map[string]*payload.Object_Timestamp, c.indexReplica-1) + err = c.discoverer.GetClient().OrderedRangeConcurrent(ctx, replicas, len(replicas), + func(ctx context.Context, addr string, conn *grpc.ClientConn, copts ...grpc.CallOption) error { + if originAddr == addr { + return nil + } + count, ok := counts[addr] // counts is read-only we don't need to lock. + if ok && count != nil && count.GetStored() == 0 && count.GetUncommitted() == 0 { + mu.Lock() + skipped = append(skipped, addr) + mu.Unlock() + return nil + } + + ots, err := vc.NewValdClient(conn).GetTimestamp(ctx, &payload.Object_TimestampRequest{ + Id: &payload.Object_ID{ + Id: id, + }, + }) + if err != nil { + if st, ok := status.FromError(err); !ok || st == nil { + log.Errorf("gRPC call GetTimestamp to agent: %s, id: %s returned not a gRPC status error: %v", addr, id, err) + return err + } else if st.Code() == codes.NotFound { + // when replica of agent > index replica, this happens + return nil + } else if st.Code() == codes.Canceled { + return nil + } else { + log.Errorf("failed to GetTimestamp with unexpected error. agent: %s, id: %s, code: %v, message: %s", addr, id, st.Code(), st.Message()) + return err + } + } + + if ots == nil { + // not found + return nil + } + + // skip if the vector is inserted after correction start + if ots.GetTimestamp() > start.UnixNano() { + log.Debugf("timestamp of vector(id: %s, timestamp: %v) is newer than correction start time(%v). skipping...", + ots.GetId(), + ots.GetTimestamp(), + start.UnixNano(), + ) + return nil + } + mu.Lock() + found[addr] = ots + if latest < ots.GetTimestamp() { + latest = ots.GetTimestamp() + if latest > ts { + latestAgent = addr + } + } + mu.Unlock() + return nil + }, + ) + return +} + +func (c *correct) getLatestObject( + ctx context.Context, id, addr, latestAgent string, latest int64, +) (latestObject *payload.Object_Vector) { + _, err := c.discoverer.GetClient().Do(grpc.WithGRPCMethod(ctx, vald.PackageName+"."+vald.ObjectRPCServiceName+"/"+vald.GetObjectRPCName), latestAgent, func(ctx context.Context, + conn *grpc.ClientConn, + copts ...grpc.CallOption, + ) (any, error) { + obj, err := vc.NewValdClient(conn).GetObject(ctx, &payload.Object_VectorRequest{ + Id: &payload.Object_ID{ + Id: id, + }, + }, copts...) + if err != nil { + if st, ok := status.FromError(err); !ok || st == nil { + log.Errorf("gRPC call returned not a gRPC status error: %v", err) + return nil, err + } else if st.Code() == codes.NotFound { + return nil, nil + } else if st.Code() == codes.Canceled { + return nil, nil + } + return nil, err + } + if obj == nil { + // not found + return nil, nil + } + if obj.GetTimestamp() >= latest && obj.GetId() != "" && obj.GetVector() != nil { + latestObject = obj + } + return obj, nil + }) + if err != nil { + log.Errorf("failed to load latest object id: %s, agent: %s, timestamp: %d, error: %v", id, addr, latest, err) + } + if latestObject != nil && latestObject.GetTimestamp() < latest { + latestObject.Timestamp = latest + } + return latestObject +} + +func (c *correct) correctTimestamp( + ctx context.Context, + id string, + latestObject *payload.Object_Vector, + found map[string]*payload.Object_Timestamp, +) { + tss := time.Unix(0, latestObject.GetTimestamp()).Format(time.RFC3339Nano) // timestamp string + for addr, ots := range found { // correct timestamp inconsistency + if latestObject.GetTimestamp() > ots.GetTimestamp() { + log.Infof("timestamp inconsistency detected with vector(id: %s, timestamp: %s). updating with the latest vector(id: %s, timestamp: %s)", + ots.GetId(), + time.Unix(0, ots.GetTimestamp()).Format(time.RFC3339Nano), + latestObject.GetId(), + tss, + ) + _, err := c.discoverer.GetClient().Do(grpc.WithGRPCMethod(ctx, vald.PackageName+"."+vald.UpdateRPCServiceName+"/"+vald.UpdateRPCName), addr, func(ctx context.Context, + conn *grpc.ClientConn, + copts ...grpc.CallOption, + ) (any, error) { + client := vc.NewValdClient(conn) + // TODO: use UpdateTimestamp when it's implemented because here we just want to update only the timestamp but not the vector + _, err := client.Update(ctx, &payload.Update_Request{ + Vector: latestObject, + // TODO: this should be deleted after Config.Timestamp deprecation + Config: &payload.Update_Config{ + // TODO: Decrementing because it's gonna be incremented before being pushed + // to vqueue in the agent. This is a not ideal workaround for the current vqueue implementation + // so we should consider refactoring vqueue. + Timestamp: latestObject.GetTimestamp() - 1, + }, + }, copts...) + if err != nil { + if st, ok := status.FromError(err); !ok || st == nil { + log.Errorf("gRPC call returned not a gRPC status error: %v", err) + return nil, err + } else if st.Code() == codes.NotFound { + _, err = client.Insert(ctx, &payload.Insert_Request{ + Vector: latestObject, + // TODO: this should be deleted after Config.Timestamp deprecation + Config: &payload.Insert_Config{ + // TODO: Decrementing because it's gonna be incremented before being pushed + // to vqueue in the agent. This is a not ideal workaround for the current vqueue implementation + // so we should consider refactoring vqueue. + Timestamp: latestObject.GetTimestamp(), }, - ); err != nil { - return err - } - latestObject := vec - - // current object timestamp is not latest get latest object from other agent index replica - if vec.GetTimestamp() < latest && latestAgent != addr { - _, err := c.discoverer.GetClient().Do(grpc.WithGRPCMethod(egctx, vald.PackageName+"."+vald.ObjectRPCServiceName+"/"+vald.GetObjectRPCName), latestAgent, func(ctx context.Context, - conn *grpc.ClientConn, - copts ...grpc.CallOption, - ) (any, error) { - obj, err := vald.NewObjectClient(conn).GetObject(ctx, &payload.Object_VectorRequest{ + }, copts...) + if err != nil { + if st, ok = status.FromError(err); !ok || st == nil { + log.Errorf("gRPC call returned not a gRPC status error: %v", err) + return nil, err + } else if st.Code() == codes.AlreadyExists { + var obj *payload.Object_Vector + obj, err = client.GetObject(ctx, &payload.Object_VectorRequest{ Id: &payload.Object_ID{ Id: id, }, }, copts...) if err != nil { - if st, ok := status.FromError(err); !ok { + if st, ok = status.FromError(err); !ok || st == nil { log.Errorf("gRPC call returned not a gRPC status error: %v", err) return nil, err } else if st.Code() == codes.NotFound { @@ -428,285 +511,198 @@ func (c *correct) Start(ctx context.Context) (err error) { } return nil, err } - if obj.GetTimestamp() >= latest && obj.GetId() != "" && obj.GetVector() != nil { - latestObject = obj - } - return obj, nil - }) - if err != nil { - log.Error(fmt.Errorf("failed to load latest object id: %s, agent: %s, timestamp: %d, error: %w", id, addr, latest, err)) - } - } - if latestObject.Timestamp < latest { - latestObject.Timestamp = latest - } - tss := time.Unix(0, latestObject.GetTimestamp()).Format(time.RFC3339Nano) // timestamp string - for addr, ots := range found { // correct timestamp inconsistency - if latestObject.GetTimestamp() > ots.GetTimestamp() { - log.Infof("timestamp inconsistency detected with vector(id: %s, timestamp: %s). updating with the latest vector(id: %s, timestamp: %s)", - ots.GetId(), - time.Unix(0, ots.GetTimestamp()).Format(time.RFC3339Nano), - latestObject.GetId(), - tss, - ) - _, err := c.discoverer.GetClient().Do(grpc.WithGRPCMethod(egctx, vald.PackageName+"."+vald.UpdateRPCServiceName+"/"+vald.UpdateRPCName), addr, func(ctx context.Context, - conn *grpc.ClientConn, - copts ...grpc.CallOption, - ) (any, error) { - client := vald.NewValdClient(conn) - // TODO: use UpdateTimestamp when it's implemented because here we just want to update only the timestamp but not the vector - _, err := client.Update(ctx, &payload.Update_Request{ + if obj != nil && obj.GetTimestamp() < latestObject.GetTimestamp() { + _, err = client.Update(ctx, &payload.Update_Request{ Vector: latestObject, // TODO: this should be deleted after Config.Timestamp deprecation Config: &payload.Update_Config{ - // TODO: Decrementing because it's gonna be incremented befor being pushed + // TODO: Decrementing because it's gonna be incremented before being pushed // to vqueue in the agent. This is a not ideal workaround for the current vqueue implementation // so we should consider refactoring vqueue. Timestamp: latestObject.GetTimestamp() - 1, }, }, copts...) if err != nil { - if st, ok := status.FromError(err); !ok { + if st, ok = status.FromError(err); !ok || st == nil { log.Errorf("gRPC call returned not a gRPC status error: %v", err) return nil, err } else if st.Code() == codes.NotFound { - _, err = client.Insert(ctx, &payload.Insert_Request{ - Vector: latestObject, - // TODO: this should be deleted after Config.Timestamp deprecation - Config: &payload.Insert_Config{ - // TODO: Decrementing because it's gonna be incremented befor being pushed - // to vqueue in the agent. This is a not ideal workaround for the current vqueue implementation - // so we should consider refactoring vqueue. - Timestamp: latestObject.GetTimestamp(), - }, - }, copts...) - if err != nil { - if st, ok = status.FromError(err); !ok { - log.Errorf("gRPC call returned not a gRPC status error: %v", err) - return nil, err - } else if st.Code() == codes.AlreadyExists { - obj, err := client.GetObject(ctx, &payload.Object_VectorRequest{ - Id: &payload.Object_ID{ - Id: id, - }, - }, copts...) - if err != nil { - if st, ok = status.FromError(err); !ok { - log.Errorf("gRPC call returned not a gRPC status error: %v", err) - return nil, err - } else if st.Code() == codes.NotFound { - return nil, nil - } else if st.Code() == codes.Canceled { - return nil, nil - } - return nil, err - } - if obj.GetTimestamp() < latestObject.GetTimestamp() { - _, err = client.Update(ctx, &payload.Update_Request{ - Vector: latestObject, - // TODO: this should be deleted after Config.Timestamp deprecation - Config: &payload.Update_Config{ - // TODO: Decrementing because it's gonna be incremented befor being pushed - // to vqueue in the agent. This is a not ideal workaround for the current vqueue implementation - // so we should consider refactoring vqueue. - Timestamp: latestObject.GetTimestamp() - 1, - }, - }, copts...) - if err != nil { - if st, ok = status.FromError(err); !ok { - log.Errorf("gRPC call returned not a gRPC status error: %v", err) - return nil, err - } else if st.Code() == codes.NotFound { - return nil, nil - } else if st.Code() == codes.Canceled { - return nil, nil - } - return nil, err - } - } - return nil, nil - } else if st.Code() == codes.Canceled { - return nil, nil - } - return nil, err - } - c.correctedOldIndexCount.Add(1) return nil, nil } else if st.Code() == codes.Canceled { return nil, nil } return nil, err } - log.Infof("vector successfully updated. address: %s, uuid: %s, timestamp: %s", addr, latestObject.GetId(), tss) c.correctedOldIndexCount.Add(1) - return nil, nil - }) - if err != nil { - log.Error(fmt.Errorf("failed to fix timestamp to %s for id %s agent %s error: %w", tss, id, addr, err)) } + return nil, nil + } else if st.Code() == codes.Canceled { + return nil, nil } + return nil, err } - currentNumberOfIndexReplica := len(found) + 1 - diff := c.indexReplica - currentNumberOfIndexReplica - addrs := c.discoverer.GetAddrs(egctx) - if diff > 0 { // correct index replica shortage - log.Infof("replica shortage(diff=%d) of vector id: %s detected for %s. inserting to other agents = %v", diff, id, debugMsg, addrs) - if len(addrs) == 0 { - return errors.ErrNoAvailableAgentToInsert - } - req := &payload.Insert_Request{ - Vector: latestObject, - // TODO: this should be deleted after Config.Timestamp deprecation - Config: &payload.Insert_Config{ - Timestamp: latestObject.GetTimestamp(), - }, - } - for _, daddr := range addrs { - if diff > 0 && daddr != addr { - _, ok := found[daddr] - if !ok { - _, err := c.discoverer.GetClient().Do(grpc.WithGRPCMethod(egctx, vald.PackageName+"."+vald.InsertRPCServiceName+"/"+vald.InsertRPCName), daddr, func(ctx context.Context, - conn *grpc.ClientConn, - copts ...grpc.CallOption, - ) (any, error) { - client := vald.NewValdClient(conn) - _, err := client.Insert(ctx, req, copts...) - if err != nil { - if st, ok := status.FromError(err); !ok { - log.Errorf("gRPC call returned not a gRPC status error: %v", err) - return nil, err - } else if st.Code() == codes.AlreadyExists { - obj, err := client.GetObject(ctx, &payload.Object_VectorRequest{ - Id: &payload.Object_ID{ - Id: id, - }, - }, copts...) - if err != nil { - if st, ok = status.FromError(err); !ok { - log.Errorf("gRPC call returned not a gRPC status error: %v", err) - return nil, err - } else if st.Code() == codes.NotFound { - return nil, nil - } else if st.Code() == codes.Canceled { - return nil, nil - } - return nil, err - } - if obj.GetTimestamp() < latestObject.GetTimestamp() { - _, err = client.Update(ctx, &payload.Update_Request{ - Vector: latestObject, - // TODO: this should be deleted after Config.Timestamp deprecation - Config: &payload.Update_Config{ - // TODO: Decrementing because it's gonna be incremented befor being pushed - // to vqueue in the agent. This is a not ideal workaround for the current vqueue implementation - // so we should consider refactoring vqueue. - Timestamp: latestObject.GetTimestamp() - 1, - }, - }, copts...) - if err != nil { - if st, ok = status.FromError(err); !ok { - log.Errorf("gRPC call returned not a gRPC status error: %v", err) - return nil, err - } else if st.Code() == codes.NotFound { - return nil, nil - } else if st.Code() == codes.Canceled { - return nil, nil - } - return nil, err - } - c.correctedOldIndexCount.Add(1) - } - diff-- - c.correctedReplicationCount.Add(1) - return nil, nil - } else if st.Code() == codes.Canceled { - return nil, nil - } - return nil, err - } - diff-- - c.correctedReplicationCount.Add(1) - return nil, nil - }) - if err != nil { - log.Error(fmt.Errorf("failed to insert object to agent(%s): %w", daddr, err)) - } - } - } - } - } else if diff < 0 { // correct index replica oversupply - log.Infof("replica oversupply of vector %s. deleting...", id) - if len(addrs) == 0 { - return errors.ErrNoAvailableAgentToRemove - } - req := &payload.Remove_Request{ + c.correctedOldIndexCount.Add(1) + return nil, nil + } else if st.Code() == codes.Canceled { + return nil, nil + } + return nil, err + } + log.Infof("vector successfully updated. address: %s, uuid: %s, timestamp: %s", addr, latestObject.GetId(), tss) + c.correctedOldIndexCount.Add(1) + return nil, nil + }) + if err != nil { + log.Error(fmt.Errorf("failed to fix timestamp to %s for id %s agent %s error: %w", tss, id, addr, err)) + } + } + } +} + +func (c *correct) correctOversupply( + ctx context.Context, + id, selfAddr, debugMsg string, + found map[string]*payload.Object_Timestamp, + diff int, +) (err error) { + addrs := c.discoverer.GetAddrs(ctx) + log.Infof("replica oversupply(configured: %d, stored: %d, diff: %d) of vector id: %s detected for %s. deleting from agents = %v", c.indexReplica, len(found)+1, diff, id, debugMsg, found) + if len(addrs) == 0 { + return errors.ErrNoAvailableAgentToRemove + } + req := &payload.Remove_Request{ + Id: &payload.Object_ID{ + Id: id, + }, + } + for _, daddr := range addrs { + if diff < 0 { + _, ok := found[daddr] + if ok || daddr == selfAddr { + _, err := c.discoverer.GetClient().Do(grpc.WithGRPCMethod(ctx, vald.PackageName+"."+vald.RemoveRPCServiceName+"/"+vald.RemoveRPCName), daddr, func(ctx context.Context, + conn *grpc.ClientConn, + copts ...grpc.CallOption, + ) (any, error) { + _, err := vc.NewValdClient(conn).Remove(ctx, req, copts...) + if err != nil { + if st, ok := status.FromError(err); !ok || st == nil { + log.Errorf("gRPC call returned not a gRPC status error: %v", err) + return nil, err + } else if st.Code() == codes.NotFound { + diff++ + c.correctedReplicationCount.Add(1) + return nil, nil + } else if st.Code() == codes.Canceled { + return nil, nil + } + return nil, err + } + diff++ + c.correctedReplicationCount.Add(1) + return nil, nil + }) + if err != nil { + log.Error(fmt.Errorf("failed to delete object from agent(%s): %w", daddr, err)) + } + } + } + } + return nil +} + +func (c *correct) correctShortage( + ctx context.Context, + id, selfAddr, debugMsg string, + latestObject *payload.Object_Vector, + found map[string]*payload.Object_Timestamp, + diff int, +) (err error) { + addrs := c.discoverer.GetAddrs(ctx) + log.Infof("replica shortage(configured: %d, stored: %d, diff: %d) of vector id: %s detected for %s. inserting to other agents = %v", c.indexReplica, len(found)+1, diff, id, debugMsg, addrs) + if len(addrs) == 0 { + return errors.ErrNoAvailableAgentToInsert + } + req := &payload.Insert_Request{ + Vector: latestObject, + // TODO: this should be deleted after Config.Timestamp deprecation + Config: &payload.Insert_Config{ + Timestamp: latestObject.GetTimestamp(), + }, + } + for _, daddr := range addrs { + if diff > 0 && daddr != selfAddr { + _, ok := found[daddr] + if !ok { + _, err := c.discoverer.GetClient().Do(grpc.WithGRPCMethod(ctx, vald.PackageName+"."+vald.InsertRPCServiceName+"/"+vald.InsertRPCName), daddr, func(ctx context.Context, + conn *grpc.ClientConn, + copts ...grpc.CallOption, + ) (any, error) { + client := vc.NewValdClient(conn) + _, err := client.Insert(ctx, req, copts...) + if err != nil { + if st, ok := status.FromError(err); !ok || st == nil { + log.Errorf("gRPC call returned not a gRPC status error: %v", err) + return nil, err + } else if st.Code() == codes.AlreadyExists { + var obj *payload.Object_Vector + obj, err = client.GetObject(ctx, &payload.Object_VectorRequest{ Id: &payload.Object_ID{ Id: id, }, + }, copts...) + if err != nil { + if st, ok = status.FromError(err); !ok || st == nil { + log.Errorf("gRPC call returned not a gRPC status error: %v", err) + return nil, err + } else if st.Code() == codes.NotFound { + return nil, nil + } else if st.Code() == codes.Canceled { + return nil, nil + } + return nil, err } - for _, daddr := range addrs { - if diff < 0 { - _, ok := found[daddr] - if ok || daddr == addr { - _, err := c.discoverer.GetClient().Do(grpc.WithGRPCMethod(egctx, vald.PackageName+"."+vald.RemoveRPCServiceName+"/"+vald.RemoveRPCName), daddr, func(ctx context.Context, - conn *grpc.ClientConn, - copts ...grpc.CallOption, - ) (any, error) { - _, err := vald.NewRemoveClient(conn).Remove(ctx, req, copts...) - if err != nil { - if st, ok := status.FromError(err); !ok { - log.Errorf("gRPC call returned not a gRPC status error: %v", err) - return nil, err - } else if st.Code() == codes.NotFound { - diff++ - c.correctedReplicationCount.Add(1) - return nil, nil - } else if st.Code() == codes.Canceled { - return nil, nil - } - return nil, err - } - diff++ - c.correctedReplicationCount.Add(1) + if obj != nil { + if obj.GetTimestamp() < latestObject.GetTimestamp() { + _, err = client.Update(ctx, &payload.Update_Request{ + Vector: latestObject, + // TODO: this should be deleted after Config.Timestamp deprecation + Config: &payload.Update_Config{ + // TODO: Decrementing because it's gonna be incremented before being pushed + // to vqueue in the agent. This is a not ideal workaround for the current vqueue implementation + // so we should consider refactoring vqueue. + Timestamp: latestObject.GetTimestamp() - 1, + }, + }, copts...) + if err != nil { + if st, ok = status.FromError(err); !ok || st == nil { + log.Errorf("gRPC call returned not a gRPC status error: %v", err) + return nil, err + } else if st.Code() == codes.NotFound { + return nil, nil + } else if st.Code() == codes.Canceled { return nil, nil - }) - if err != nil { - log.Error(fmt.Errorf("failed to delete object from agent(%s): %w", daddr, err)) } + return nil, err } } + diff-- + c.correctedReplicationCount.Add(1) } + return nil, nil + } else if st.Code() == codes.Canceled { + return nil, nil } - return nil - })) + return nil, err + } + diff-- + c.correctedReplicationCount.Add(1) + return nil, nil + }) + if err != nil { + log.Error(fmt.Errorf("failed to insert object to agent(%s): %w", daddr, err)) } } } - }); err != nil { - // This only happens when ErrGRPCClientConnNotFound is returned. - // In other cases, OrderedRange continues processing, so error is used to keep track of the error status of correction. - errs = append(errs, err) - } - if len(errs) != 0 { - return errors.Join(errs...) } - return nil } - -func (c *correct) PreStop(_ context.Context) error { - log.Info("removing persistent cache files...") - return c.checkedList.Close(true) -} - -func (c *correct) NumberOfCheckedIndex() uint64 { - return c.checkedIndexCount.Load() -} - -func (c *correct) NumberOfCorrectedOldIndex() uint64 { - return c.correctedOldIndexCount.Load() -} - -func (c *correct) NumberOfCorrectedReplication() uint64 { - return c.correctedReplicationCount.Load() -} diff --git a/pkg/index/job/correction/usecase/corrector.go b/pkg/index/job/correction/usecase/corrector.go index 976d3ad961..5bf3b6b267 100644 --- a/pkg/index/job/correction/usecase/corrector.go +++ b/pkg/index/job/correction/usecase/corrector.go @@ -185,10 +185,10 @@ func (r *run) Start(ctx context.Context) (<-chan error, error) { } })) - // main groutine to run the job + // main goroutine to run the job r.eg.Go(safety.RecoverFunc(func() (err error) { defer func() { - log.Info("fiding my pid to kill myself") + log.Info("finding my pid to kill myself") p, err := os.FindProcess(os.Getpid()) if err != nil { // using Fatal to avoid this process to be zombie diff --git a/pkg/index/job/readreplica/rotate/service/rotator.go b/pkg/index/job/readreplica/rotate/service/rotator.go index 9975e31b1a..ef24e67889 100644 --- a/pkg/index/job/readreplica/rotate/service/rotator.go +++ b/pkg/index/job/readreplica/rotate/service/rotator.go @@ -198,7 +198,7 @@ func (s *subProcess) createSnapshot( oldSnap = cur.DeepCopy() newNameBase := getNewBaseName(cur.GetObjectMeta().GetName()) if newNameBase == "" { - return nil, nil, fmt.Errorf("the name(%s) doesn't seem to have replicaid", cur.GetObjectMeta().GetName()) + return nil, nil, fmt.Errorf("the name(%s) doesn't seem to have replica id", cur.GetObjectMeta().GetName()) } newSnap = &k8s.VolumeSnapshot{ ObjectMeta: k8s.ObjectMeta{ @@ -244,7 +244,7 @@ func (s *subProcess) createPVC( oldPvc = cur.DeepCopy() newNameBase := getNewBaseName(cur.GetObjectMeta().GetName()) if newNameBase == "" { - return nil, nil, fmt.Errorf("the name(%s) doesn't seem to have replicaid", cur.GetObjectMeta().GetName()) + return nil, nil, fmt.Errorf("the name(%s) doesn't seem to have replica id", cur.GetObjectMeta().GetName()) } // remove timestamp from old pvc name diff --git a/pkg/index/operator/service/operator.go b/pkg/index/operator/service/operator.go index dc9f476958..cfc086a58f 100644 --- a/pkg/index/operator/service/operator.go +++ b/pkg/index/operator/service/operator.go @@ -309,11 +309,11 @@ func (o *operator) ensureJobConcurrency( } for _, job := range jobList.Items { - annotaions := job.Spec.Template.Annotations - if annotaions == nil { + annotations := job.Spec.Template.Annotations + if annotations == nil { continue } - id, ok := annotaions[o.targetReadReplicaIDAnnotationsKey] + id, ok := annotations[o.targetReadReplicaIDAnnotationsKey] if !ok { continue } diff --git a/pkg/manager/index/service/indexer.go b/pkg/manager/index/service/indexer.go index 42e90b1c9b..88400fe75f 100644 --- a/pkg/manager/index/service/indexer.go +++ b/pkg/manager/index/service/indexer.go @@ -24,10 +24,10 @@ import ( "sync/atomic" "time" - agent "github.com/vdaas/vald/apis/grpc/v1/agent/core" "github.com/vdaas/vald/apis/grpc/v1/payload" - vald "github.com/vdaas/vald/apis/grpc/v1/vald" + agent "github.com/vdaas/vald/internal/client/v1/client/agent/core" "github.com/vdaas/vald/internal/client/v1/client/discoverer" + vald "github.com/vdaas/vald/internal/client/v1/client/vald" "github.com/vdaas/vald/internal/errors" "github.com/vdaas/vald/internal/log" "github.com/vdaas/vald/internal/net/grpc" diff --git a/pkg/tools/benchmark/job/config/config.go b/pkg/tools/benchmark/job/config/config.go index a81c68d1c9..03c3adc485 100644 --- a/pkg/tools/benchmark/job/config/config.go +++ b/pkg/tools/benchmark/job/config/config.go @@ -112,7 +112,7 @@ func NewConfig(ctx context.Context, path string) (cfg *Config, err error) { if jobResource.Spec.ServerConfig != nil { overrideCfg.Server = (*jobResource.Spec.ServerConfig).Bind() } - // jobResource.Spec has another field comparering Config.Job, so json.Marshal and Unmarshal are used for embedding field value of Config.Job from jobResource.Spec + // jobResource.Spec has another field comparing Config.Job, so json.Marshal and Unmarshal are used for embedding field value of Config.Job from jobResource.Spec var overrideJobCfg config.BenchmarkJob b, err := json.Marshal(*jobResource.Spec.DeepCopy()) if err == nil { diff --git a/pkg/tools/benchmark/operator/service/operator.go b/pkg/tools/benchmark/operator/service/operator.go index 187673d527..1d80e6838d 100644 --- a/pkg/tools/benchmark/operator/service/operator.go +++ b/pkg/tools/benchmark/operator/service/operator.go @@ -193,8 +193,8 @@ func (o *operator) jobReconcile(ctx context.Context, jobList map[string][]k8s.Jo } // benchmarkJobStatus is used for update benchmark job resource status benchmarkJobStatus := make(map[string]v1.BenchmarkJobStatus) - // jobNames is used for check whether cjobs has delted job. - // If cjobs has the delted job, it will be remove the end of jobReconcile function. + // jobNames is used for check whether cjobs has deleted job. + // If cjobs has the deleted job, it will be remove the end of jobReconcile function. jobNames := map[string]struct{}{} for _, jobs := range jobList { cnt := len(jobs) diff --git a/pkg/tools/benchmark/operator/service/operator_test.go b/pkg/tools/benchmark/operator/service/operator_test.go index 1e2e0abba5..70129badaa 100644 --- a/pkg/tools/benchmark/operator/service/operator_test.go +++ b/pkg/tools/benchmark/operator/service/operator_test.go @@ -2911,7 +2911,7 @@ func Test_operator_checkAtomics(t *testing.T) { tests := []test{ func() test { return test{ - name: "return nil with no mismatch atmoics", + name: "return nil with no mismatch atomics", fields: fields{ scenarios: func() *atomic.Pointer[map[string]*scenario] { ap := atomic.Pointer[map[string]*scenario]{} diff --git a/rust/bin/agent/src/handler/update.rs b/rust/bin/agent/src/handler/update.rs index c738a3dfd5..f8981b4f24 100644 --- a/rust/bin/agent/src/handler/update.rs +++ b/rust/bin/agent/src/handler/update.rs @@ -45,4 +45,12 @@ impl update_server::Update for super::Agent { ) -> std::result::Result, tonic::Status> { todo!() } + + #[doc = " A method to update timestamp indexed vectors in a single request.\n"] + async fn update_timestamp( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status> { + todo!() + } } diff --git a/rust/libs/proto/src/vald.v1.tonic.rs b/rust/libs/proto/src/vald.v1.tonic.rs index 9c856bfd0d..8c9fb776f6 100644 --- a/rust/libs/proto/src/vald.v1.tonic.rs +++ b/rust/libs/proto/src/vald.v1.tonic.rs @@ -5527,6 +5527,35 @@ pub mod update_client { .insert(GrpcMethod::new("vald.v1.Update", "MultiUpdate")); self.inner.unary(req, path, codec).await } + /** A method to update timestamp an indexed vector. +*/ + pub async fn update_timestamp( + &mut self, + request: impl tonic::IntoRequest< + super::super::super::payload::v1::object::Timestamp, + >, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/vald.v1.Update/UpdateTimestamp", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("vald.v1.Update", "UpdateTimestamp")); + self.inner.unary(req, path, codec).await + } } } /// Generated server implementations. @@ -5574,6 +5603,15 @@ pub mod update_server { tonic::Response, tonic::Status, >; + /** A method to update timestamp an indexed vector. +*/ + async fn update_timestamp( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; } #[derive(Debug)] pub struct UpdateServer { @@ -5804,6 +5842,55 @@ pub mod update_server { }; Box::pin(fut) } + "/vald.v1.Update/UpdateTimestamp" => { + #[allow(non_camel_case_types)] + struct UpdateTimestampSvc(pub Arc); + impl< + T: Update, + > tonic::server::UnaryService< + super::super::super::payload::v1::object::Timestamp, + > for UpdateTimestampSvc { + type Response = super::super::super::payload::v1::object::Location; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::super::super::payload::v1::object::Timestamp, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::update_timestamp(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = UpdateTimestampSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } _ => { Box::pin(async move { Ok( diff --git a/tests/e2e/crud/crud_test.go b/tests/e2e/crud/crud_test.go index a5ba1273ba..71969d38f9 100644 --- a/tests/e2e/crud/crud_test.go +++ b/tests/e2e/crud/crud_test.go @@ -415,7 +415,7 @@ func TestE2EStandardCRUD(t *testing.T) { err = op.Flush(t, ctx) if err != nil { - // TODO: Remove code check afeter Flush API is available for agent-faiss and mirror-gateway + // TODO: Remove code check after Flush API is available for agent-faiss and mirror-gateway st, _, _ := status.ParseError(err, codes.Unknown, "") if st.Code() != codes.Unimplemented { t.Fatalf("an error occurred: %s", err) @@ -865,7 +865,7 @@ func TestE2EReadReplica(t *testing.T) { t.Log("waiting for read replica rotator jobs to complete...") if err := kubectl.WaitResources(ctx, t, "job", "app=vald-readreplica-rotate", "complete", "60s"); err != nil { t.Log("wait failed. printing yaml of vald-readreplica-rotate") - kubectl.KubectlCmd(ctx, t, "get", "pod", "-l", "app=vald-readreplica-rotate", "-oyaml") + kubectl.KubectlCmd(ctx, t, "get", "pod", "-l", "app=vald-readreplica-rotate", "-o", "yaml") t.Log("wait failed. printing log of vald-index-operator") kubectl.DebugLog(ctx, t, "app=vald-index-operator") t.Log("wait failed. printing log of vald-readreplica-rotate") diff --git a/tests/e2e/pkg/agent/core/ngt/service/ngt_e2s_test.go b/tests/e2e/pkg/agent/core/ngt/service/ngt_e2s_test.go index 114ac6daa0..8a22351a78 100644 --- a/tests/e2e/pkg/agent/core/ngt/service/ngt_e2s_test.go +++ b/tests/e2e/pkg/agent/core/ngt/service/ngt_e2s_test.go @@ -147,7 +147,7 @@ func Test_ngt_parallel_delete_and_insert(t *testing.T) { wg.Wait() if n.Len() != maxIDNum { - t.Errorf("inerted id num = %d, want = %d", n.Len(), maxIDNum) + t.Errorf("inserted id num = %d, want = %d", n.Len(), maxIDNum) } for i := int64(0); i < maxIDNum; i++ { @@ -230,7 +230,7 @@ func Test_ngt_parallel_insert_and_delete(t *testing.T) { wg.Wait() if want, got := n.Len(), uint64(0); want != got { - t.Errorf("inerted id num = %d, want = %d", got, want) + t.Errorf("inserted id num = %d, want = %d", got, want) } for i := int64(0); i < maxIDNum; i++ { diff --git a/versions/PROMETHEUS_STACK_VERSION b/versions/PROMETHEUS_STACK_VERSION index 14e3460225..c40b5fb3e9 100644 --- a/versions/PROMETHEUS_STACK_VERSION +++ b/versions/PROMETHEUS_STACK_VERSION @@ -1 +1 @@ -61.7.1 +61.8.0 diff --git a/versions/VALDCLI_VERSION b/versions/VALDCLI_VERSION deleted file mode 100644 index b84efa430e..0000000000 --- a/versions/VALDCLI_VERSION +++ /dev/null @@ -1 +0,0 @@ -v1.7.12